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

SE5 ECEAI/eceai 2023/2024/Brenier-Nguyen

2024-01-20T14:43:32Z

Tbrenier : /* Utilisation des programmes présentés ci-dessus */

= Résumé de séance =

=== Séance 1 : ===
* Création et configuration de la VM sur Chassiron
* Installation de NanoEdge
* Installation de STM32cube
* Installation de l'OS pour la Raspberry dans la carte micro SD
* Prise en main de Nanoedge, de nucléo et de STM32cube
* Début de réflexion sur l'application (métrologie)

=== Séance 2: ===

* Mise en place du serveur python

*Mise en place du client python
*Test réussi de communication entre client et serveur via http
*Programmation de la carte nucléo pour transfert de valeur via liaison série
*Suite réflexion sur l'application (reconnaissance alphabet langue des signes, mouvement)
*Choix de l'application : reconnaissance d'objets appliqué aux fournitures scolaires
*Entraînement des modèles pour les différentes applications cités précédemment
*Finalement : entraînement à la reconnaissance d'objets de fournitures scolaires

=== Séance 3: ===
*Entraînement d'un nouveau modèle.
*Écriture d'un programme permettant de récupérer les données du capteur et de les écrire dans un fichier.

=== Séance 4 : ===
*Essai d'utilisation de la librairie créée grâce à Nanoedge.
*Amélioration du [[Code de récupération de donnée (sur la raspberry)|programme python]] permettant de récupérer les données du capteur.
**Création d'un fichier .txt afin de stocker les données du capteur toutes les minutes.
**Destruction automatique des fichiers de données ayant été crée il y a plus de 10 minutes.
*L’émulateur de la librairie ne fonctionne pas s'il est exécuté dans la raspberry... Nous l'exécutons désormais directement dans notre VM.
*Pour cela nous avons adapter notre programme python afin de récupérer les données à partir d'un json pour traiter ces données dans la VM.
**Création d'un fichier toutes les minutes (contenant au format json la date et les données au format csv)

= Programmation des interfaces du serveur =

=== <b>Code du serveur Python :</b> ===
<syntaxhighlight lang="python3">
from http.server import HTTPServer, BaseHTTPRequestHandler

import json

import socket

# Stocker les requ tes POST re ues

post_requests = []

class CustomHTTPHandler(BaseHTTPRequestHandler):

def do_GET(self):

if self.path == '/':

self.path = '/index.html'

if self.path == '/data':

self.send_response(200)

self.send_header('Content-type', 'application/json')

self.end_headers()

self.wfile.write(bytes(json.dumps(post_requests), 'utf-8'))

return

if self.path == '/index.html':

self.send_response(200)

self.send_header('Content-type', 'text/html')

self.end_headers()

# Cr er le contenu HTML avec les donn es POST

content = '<html><body><h1>Donn es POST:</h1><ul>'

for item in post_requests:

content += f'<li>{item}</li>'

content += '</ul></body></html>'

self.wfile.write(content.encode('utf-8'))

return

try:

file_to_open = open(self.path[1:]).read()

self.send_response(200)

self.send_header('Content-type', 'text/html')

self.end_headers()

self.wfile.write(bytes(file_to_open, 'utf-8'))

except FileNotFoundError:

self.send_error(404, 'File Not Found: %s' % self.path)

def do_POST(self):

content_length = int(self.headers['Content-Length'])

post_data = self.rfile.read(content_length).decode('utf-8')

# Ajouter les donn es POST la liste

post_requests.append(post_data)

# Envoyer une rponse HTTP

self.send_response(200)

self.end_headers()

self.wfile.write(b"POST request processed")

class HTTPServerV6(HTTPServer):

address_family = socket.AF_INET6

if __name__ == '__main__':

server_address = ('::', 8888) # ^icoute sur toutes les interfaces IPv6, p>

httpd = HTTPServerV6(server_address, CustomHTTPHandler)

print("Serveur actif sur le port", 8888)

httpd.serve_forever()
</syntaxhighlight>

=== '''Code du client Python :''' ===
<syntaxhighlight lang="python3">
import argparse
import requests
import json

def send_json_to_server(url, json_file):
# Charger les données CSV depuis le fichier spécifié
with open(json_file, 'r') as file:
data = json.load(file)

# En-têtes spécifiant que vous envoyez du CSV
headers = {'Content-Type': 'application/json'}

# Envoie de la requête HTTP POST avec les données
response = requests.post(url, data=json.dumps(data), headers=headers)

# Vérification de la réponse
if response.status_code == 200:
print('Requête envoyée avec succès!')
else:
print(f'Erreur {response.status_code}: {response.text}')

if __name__ == "__main__":
# Configurer les arguments en ligne de commande
parser = argparse.ArgumentParser(description='Client Python pour envoyer des JSON via HTTP.')
parser.add_argument('url', type=str, help='URL du serveur')
parser.add_argument('json_file', type=str, help='Chemin vers le fichier JSON à envoyer')

# Analyser les arguments
args = parser.parse_args()

# Appeler la fonction pour envoyer le JSON au serveur
send_json_to_server(args.url, args.json_file)
</syntaxhighlight>

=== '''Index permettant d'afficher le json de test que nous avons envoyé au serveur :''' ===
<syntaxhighlight lang="html">
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>Page d'Accueil</title>
</head>
<body>
<h1>Bienvenue sur Mon Serveur</h1>
<h2>Données POST reçues:</h2>
<ul id="data">

</ul>
</body>
</html>

</syntaxhighlight>

=== '''Capture montrant l'affichage d'un fichier json (sans aucun sens) envoyé au serveur depuis le client :''' ===

= Flash du capteur sur le logiciel STM32CubeIDE =
Le code ci-dessous est la fonction qui est appelé pour le traitement des capteurs. Nous avions décidé de définir le délimiteur de donnée avec un espace.
[[Fichier:CaptureIndexBrenierNguyen.png|centre|Démonstration du protocole HTTP]]

Ci-dessous, on retrouve de la ligne 8 à 12 la configuration du capteur que l'on a défini sur un quadrillage de 8 x 8.<syntaxhighlight lang="c" line="1">
static void MX_53L5A1_SimpleRanging_Process(void)
{
uint32_t Id;

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 */

/* 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);

if (status == BSP_ERROR_NONE)
{
//print_result(&Result);
print_result_IE(&Result);
}

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

HAL_Delay(POLLING_PERIOD);
}
}
</syntaxhighlight>Le code ci-dessous est la fonction qui nous permet d'afficher les données des capteurs via la liaison série.

On observe l'envoie des données avec un séparateur 'espace', puis lorsque les valeurs semblent incohérentes du point de vue du capteur, on envoie arbitrairement un -1 en sortie.

On obtient un jeu de donnée suivant le format : value espace value esapce .... value espace retour chariot (pour chaque lignes/quadrillage sur une ligne)<syntaxhighlight lang="c">
static void print_result_IE(RANGING_SENSOR_Result_t *Result)
{
int8_t j;
int8_t k;
int8_t l;
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("%ld ",(long)Result->ZoneResult[j+k].Distance[l]);
else
printf("%ld ", -1);
}
}
}
printf("\n");
}
</syntaxhighlight>

= Code de récupération de donnée (sur la raspberry) =
Nous avons le scénario suivant : le capteur qui envoie en continue les données de distance à la raspberry via la liaison série.

Nous avons donc écrit un script python afin de récupérer ces données, les formater dans un fichier format json dans le but de les envoyer sur la VM qui pourra traiter ces données avec l'émulateur obtenue via l'application NanoEdgeAI Studio.

Nous allons vous expliquez le script que nous avons réalisés :<syntaxhighlight lang="python3" line="1">
import serial
from threading import Thread, Event
from time import sleep
import os, sys, signal
import datetime
import glob

# Événement pour signaler l'arrêt des threads
interruptAllEvent = Event()

# Fonction de thread pour lire les données et les sauvegarder dans des fichiers
def serial_thread(ser: serial) -> None:
# Chemin du fichier pour les données initiales du capteur
# Ces données sont vouées à ne pas être utilisées
fileName_old = os.path.dirname(__file__) + "/data/sensor_data_start"

while (1):
if (interruptAllEvent.is_set()):
break

# Créer un nouveau fichier pour chaque minute avec l'horodatage actuel
fileName = os.path.dirname(__file__) + "/data/sensor_data_" + datetime.datetime.now().strftime("%d_%m_%Y__%H_%M_00") + ".json"

# Fermer le fichier de la minute précédente en ajoutant la parenthèse fermante
if (fileName_old != fileName):
with open(fileName_old, "a") as fichier:
fichier.write("\"}")

# Lire les données du port série
string = str(ser.readline(), encoding='utf-8')

# Ouvrir le fichier de la minute actuelle et écrire les données
with open(fileName, "a") as fichier:
# S'il s'agit d'une nouvelle minute, commencer un nouvel objet JSON
if (fileName_old != fileName):
fileName_old = fileName
fichier.write("{\"date\":\""+datetime.datetime.now().strftime("%d/%m/%Y-%H:%M:00")+"\",\"csv_file\":\"")

# Écrire les données dans le fichier
fichier.write(string)

# Gestionnaire de signal pour définir l'événement d'interruption lors d'une interruption clavier (Ctrl+C)
def signal_handler(sig, frame):
interruptAllEvent.set()
return

# Fonction principale
def main() -> None:
# Créer un objet pour la communication série
ser = serial.Serial('/dev/ttyACM0', 460800)

# Créer un thread pour la communication série
thread = Thread(target=serial_thread, args=(ser,))

# Démarrer le thread de communication série
thread.start()

# Mettre en place le gestionnaire de signal pour les événements d'interruption (Ctrl+C)
signal.signal(signal.SIGINT, signal_handler)

# Attendre pendant 5 secondes et supprimer le fichier de données initial du capteur
sleep(5)
os.remove(os.path.dirname(__file__) + "/data/sensor_data_start")

while (1):
# Vérifier si l'événement d'interruption est défini
if interruptAllEvent.is_set():
# Attendre que le thread série se termine, puis sortir de la boucle
thread.join()
break

sleep(5)

# Ajuster les valeurs de minute et d'heure pour l'heure précédente
minute = datetime.datetime.now().minute - 1
hours = datetime.datetime.now().hour
if (minute < 0):
minute = minute + 60
hours = hours - 1

# On modifie tout les \n du fichier json afin que son transfert et sa réception vers le serveur
# soit du bon format. On protège donc tout les \n du fichier avant son envoie.
try:
# Lire et modifier le contenu du fichier de la minute précédente
with open(os.path.dirname(__file__) + "/data/sensor_data_" + datetime.datetime.now().strftime("%d_%m_%Y__") + str(hours) + "_" + str(minute) + "_00.json", "r+") as fichier:
line = fichier.read()
str(line).replace('\n','\\\n')
fichier.write(line)
except FileNotFoundError:
sleep(60)

# Créer une liste de chemins de fichiers pour les 10 dernières minutes
# Tout les autres sont amenés à être supprimés. Dans le but de préserver de la mémoire de stockage
file_to_keep = []
for i in range(0,10):
minute = datetime.datetime.now().minute - i
hours = datetime.datetime.now().hour
if (minute < 0):
minute = minute + 60
hours = hours - 1
path_string = os.path.dirname(__file__) + "/data/sensor_data_" + datetime.datetime.now().strftime("%d_%m_%Y__") + str(hours) + "_" + str(minute) + "_00.json"
file_to_keep.append(path_string)

# Obtenir une liste de tous les fichiers dans le répertoire data
files = glob.glob(os.path.dirname(__file__) + "/data/*")

# Créer une liste de fichiers à supprimer
files_to_remove = []

# Vérifier chaque fichier et l'ajouter à la liste de suppression s'il n'est pas dans la liste des fichiers à conserver
for file_name in files:
beRemoved = True
for f_keep in file_to_keep:
if file_name == f_keep:
beRemoved = False
break
if beRemoved:
files_to_remove.append(file_name)

# Supprimer les fichiers de la liste de suppression
for file_name in files_to_remove:
os.remove(file_name)

# Point d'entrée du script
if __name__ == '__main__':
main()

</syntaxhighlight>

= Utilisation des programmes présentés ci-dessus =
Nous avons entrainé le programme grâce au logiciel NanoEdge Studio AI, à reconnaitre différentes fournitures scolaires.

Voici ci-dessous un exemple de résultat renvoyés avec aucun objet, une colle et un stabilo.[[Fichier:20231220 173650.jpg|gauche|vignette|Aucun objet à reconnaitre]]
[[Fichier:20231220 173812.jpg|vignette|Un stabilo à reconnaitre]]
[[Fichier:20231220 173733.jpg|centre|vignette|Une colle à reconnaitre]]Nous pouvons voir sur la première image que c'est la classe "X" qui est reconnu avec une probabilité de 100%. Sur la seconde image la classe "Colle" est reconnu à 94%. Enfin sur la dernière image la classe "Stabilo" est reconnu à 100%.

A première vue ce sont de bons résultats, cependant ils sont obtenus dans des conditions d'expérimentation fixe, le capteur est toujours à la même distance de la table. Les résultats chutes drastiquement si l'on change la position du capteur. Il faudrait donc entraîner d'avantage le programme dans d'autres conditions afin qu'il soit plus performant.

SE5 ECEAI/eceai 2023/2024/Brenier-Nguyen

2024-01-20T14:23:45Z

Tbrenier : /* Code du client Python : */

= Résumé de séance =

=== Séance 1 : ===
* Création et configuration de la VM sur Chassiron
* Installation de NanoEdge
* Installation de STM32cube
* Installation de l'OS pour la Raspberry dans la carte micro SD
* Prise en main de Nanoedge, de nucléo et de STM32cube
* Début de réflexion sur l'application (métrologie)

=== Séance 2: ===

* Mise en place du serveur python

*Mise en place du client python
*Test réussi de communication entre client et serveur via http
*Programmation de la carte nucléo pour transfert de valeur via liaison série
*Suite réflexion sur l'application (reconnaissance alphabet langue des signes, mouvement)
*Choix de l'application : reconnaissance d'objets appliqué aux fournitures scolaires
*Entraînement des modèles pour les différentes applications cités précédemment
*Finalement : entraînement à la reconnaissance d'objets de fournitures scolaires

=== Séance 3: ===
*Entraînement d'un nouveau modèle.
*Écriture d'un programme permettant de récupérer les données du capteur et de les écrire dans un fichier.

=== Séance 4 : ===
*Essai d'utilisation de la librairie créée grâce à Nanoedge.
*Amélioration du [[Code de récupération de donnée (sur la raspberry)|programme python]] permettant de récupérer les données du capteur.
**Création d'un fichier .txt afin de stocker les données du capteur toutes les minutes.
**Destruction automatique des fichiers de données ayant été crée il y a plus de 10 minutes.
*L’émulateur de la librairie ne fonctionne pas s'il est exécuté dans la raspberry... Nous l'exécutons désormais directement dans notre VM.
*Pour cela nous avons adapter notre programme python afin de récupérer les données à partir d'un json pour traiter ces données dans la VM.
**Création d'un fichier toutes les minutes (contenant au format json la date et les données au format csv)

= Programmation des interfaces du serveur =

=== <b>Code du serveur Python :</b> ===
<syntaxhighlight lang="python3">
from http.server import HTTPServer, BaseHTTPRequestHandler

import json

import socket

# Stocker les requ tes POST re ues

post_requests = []

class CustomHTTPHandler(BaseHTTPRequestHandler):

def do_GET(self):

if self.path == '/':

self.path = '/index.html'

if self.path == '/data':

self.send_response(200)

self.send_header('Content-type', 'application/json')

self.end_headers()

self.wfile.write(bytes(json.dumps(post_requests), 'utf-8'))

return

if self.path == '/index.html':

self.send_response(200)

self.send_header('Content-type', 'text/html')

self.end_headers()

# Cr er le contenu HTML avec les donn es POST

content = '<html><body><h1>Donn es POST:</h1><ul>'

for item in post_requests:

content += f'<li>{item}</li>'

content += '</ul></body></html>'

self.wfile.write(content.encode('utf-8'))

return

try:

file_to_open = open(self.path[1:]).read()

self.send_response(200)

self.send_header('Content-type', 'text/html')

self.end_headers()

self.wfile.write(bytes(file_to_open, 'utf-8'))

except FileNotFoundError:

self.send_error(404, 'File Not Found: %s' % self.path)

def do_POST(self):

content_length = int(self.headers['Content-Length'])

post_data = self.rfile.read(content_length).decode('utf-8')

# Ajouter les donn es POST la liste

post_requests.append(post_data)

# Envoyer une rponse HTTP

self.send_response(200)

self.end_headers()

self.wfile.write(b"POST request processed")

class HTTPServerV6(HTTPServer):

address_family = socket.AF_INET6

if __name__ == '__main__':

server_address = ('::', 8888) # ^icoute sur toutes les interfaces IPv6, p>

httpd = HTTPServerV6(server_address, CustomHTTPHandler)

print("Serveur actif sur le port", 8888)

httpd.serve_forever()
</syntaxhighlight>

=== '''Code du client Python :''' ===
<syntaxhighlight lang="python3">
import argparse
import requests
import json

def send_json_to_server(url, json_file):
# Charger les données CSV depuis le fichier spécifié
with open(json_file, 'r') as file:
data = json.load(file)

# En-têtes spécifiant que vous envoyez du CSV
headers = {'Content-Type': 'application/json'}

# Envoie de la requête HTTP POST avec les données
response = requests.post(url, data=json.dumps(data), headers=headers)

# Vérification de la réponse
if response.status_code == 200:
print('Requête envoyée avec succès!')
else:
print(f'Erreur {response.status_code}: {response.text}')

if __name__ == "__main__":
# Configurer les arguments en ligne de commande
parser = argparse.ArgumentParser(description='Client Python pour envoyer des JSON via HTTP.')
parser.add_argument('url', type=str, help='URL du serveur')
parser.add_argument('json_file', type=str, help='Chemin vers le fichier JSON à envoyer')

# Analyser les arguments
args = parser.parse_args()

# Appeler la fonction pour envoyer le JSON au serveur
send_json_to_server(args.url, args.json_file)
</syntaxhighlight>

=== '''Index permettant d'afficher le json de test que nous avons envoyé au serveur :''' ===
<syntaxhighlight lang="html">
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>Page d'Accueil</title>
</head>
<body>
<h1>Bienvenue sur Mon Serveur</h1>
<h2>Données POST reçues:</h2>
<ul id="data">

</ul>
</body>
</html>

</syntaxhighlight>

=== '''Capture montrant l'affichage d'un fichier json (sans aucun sens) envoyé au serveur depuis le client :''' ===

= Flash du capteur sur le logiciel STM32CubeIDE =
Le code ci-dessous est la fonction qui est appelé pour le traitement des capteurs. Nous avions décidé de définir le délimiteur de donnée avec un espace.
[[Fichier:CaptureIndexBrenierNguyen.png|centre|Démonstration du protocole HTTP]]

Ci-dessous, on retrouve de la ligne 8 à 12 la configuration du capteur que l'on a défini sur un quadrillage de 8 x 8.<syntaxhighlight lang="c" line="1">
static void MX_53L5A1_SimpleRanging_Process(void)
{
uint32_t Id;

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 */

/* 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);

if (status == BSP_ERROR_NONE)
{
//print_result(&Result);
print_result_IE(&Result);
}

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

HAL_Delay(POLLING_PERIOD);
}
}
</syntaxhighlight>Le code ci-dessous est la fonction qui nous permet d'afficher les données des capteurs via la liaison série.

On observe l'envoie des données avec un séparateur 'espace', puis lorsque les valeurs semblent incohérentes du point de vue du capteur, on envoie arbitrairement un -1 en sortie.

On obtient un jeu de donnée suivant le format : value espace value esapce .... value espace retour chariot (pour chaque lignes/quadrillage sur une ligne)<syntaxhighlight lang="c">
static void print_result_IE(RANGING_SENSOR_Result_t *Result)
{
int8_t j;
int8_t k;
int8_t l;
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("%ld ",(long)Result->ZoneResult[j+k].Distance[l]);
else
printf("%ld ", -1);
}
}
}
printf("\n");
}
</syntaxhighlight>

= Code de récupération de donnée (sur la raspberry) =
Nous avons le scénario suivant : le capteur qui envoie en continue les données de distance à la raspberry via la liaison série.

Nous avons donc écrit un script python afin de récupérer ces données, les formater dans un fichier format json dans le but de les envoyer sur la VM qui pourra traiter ces données avec l'émulateur obtenue via l'application NanoEdgeAI Studio.

Nous allons vous expliquez le script que nous avons réalisés :<syntaxhighlight lang="python3" line="1">
import serial
from threading import Thread, Event
from time import sleep
import os, sys, signal
import datetime
import glob

# Événement pour signaler l'arrêt des threads
interruptAllEvent = Event()

# Fonction de thread pour lire les données et les sauvegarder dans des fichiers
def serial_thread(ser: serial) -> None:
# Chemin du fichier pour les données initiales du capteur
# Ces données sont vouées à ne pas être utilisées
fileName_old = os.path.dirname(__file__) + "/data/sensor_data_start"

while (1):
if (interruptAllEvent.is_set()):
break

# Créer un nouveau fichier pour chaque minute avec l'horodatage actuel
fileName = os.path.dirname(__file__) + "/data/sensor_data_" + datetime.datetime.now().strftime("%d_%m_%Y__%H_%M_00") + ".json"

# Fermer le fichier de la minute précédente en ajoutant la parenthèse fermante
if (fileName_old != fileName):
with open(fileName_old, "a") as fichier:
fichier.write("\"}")

# Lire les données du port série
string = str(ser.readline(), encoding='utf-8')

# Ouvrir le fichier de la minute actuelle et écrire les données
with open(fileName, "a") as fichier:
# S'il s'agit d'une nouvelle minute, commencer un nouvel objet JSON
if (fileName_old != fileName):
fileName_old = fileName
fichier.write("{\"date\":\""+datetime.datetime.now().strftime("%d/%m/%Y-%H:%M:00")+"\",\"csv_file\":\"")

# Écrire les données dans le fichier
fichier.write(string)

# Gestionnaire de signal pour définir l'événement d'interruption lors d'une interruption clavier (Ctrl+C)
def signal_handler(sig, frame):
interruptAllEvent.set()
return

# Fonction principale
def main() -> None:
# Créer un objet pour la communication série
ser = serial.Serial('/dev/ttyACM0', 460800)

# Créer un thread pour la communication série
thread = Thread(target=serial_thread, args=(ser,))

# Démarrer le thread de communication série
thread.start()

# Mettre en place le gestionnaire de signal pour les événements d'interruption (Ctrl+C)
signal.signal(signal.SIGINT, signal_handler)

# Attendre pendant 5 secondes et supprimer le fichier de données initial du capteur
sleep(5)
os.remove(os.path.dirname(__file__) + "/data/sensor_data_start")

while (1):
# Vérifier si l'événement d'interruption est défini
if interruptAllEvent.is_set():
# Attendre que le thread série se termine, puis sortir de la boucle
thread.join()
break

sleep(5)

# Ajuster les valeurs de minute et d'heure pour l'heure précédente
minute = datetime.datetime.now().minute - 1
hours = datetime.datetime.now().hour
if (minute < 0):
minute = minute + 60
hours = hours - 1

# On modifie tout les \n du fichier json afin que son transfert et sa réception vers le serveur
# soit du bon format. On protège donc tout les \n du fichier avant son envoie.
try:
# Lire et modifier le contenu du fichier de la minute précédente
with open(os.path.dirname(__file__) + "/data/sensor_data_" + datetime.datetime.now().strftime("%d_%m_%Y__") + str(hours) + "_" + str(minute) + "_00.json", "r+") as fichier:
line = fichier.read()
str(line).replace('\n','\\\n')
fichier.write(line)
except FileNotFoundError:
sleep(60)

# Créer une liste de chemins de fichiers pour les 10 dernières minutes
# Tout les autres sont amenés à être supprimés. Dans le but de préserver de la mémoire de stockage
file_to_keep = []
for i in range(0,10):
minute = datetime.datetime.now().minute - i
hours = datetime.datetime.now().hour
if (minute < 0):
minute = minute + 60
hours = hours - 1
path_string = os.path.dirname(__file__) + "/data/sensor_data_" + datetime.datetime.now().strftime("%d_%m_%Y__") + str(hours) + "_" + str(minute) + "_00.json"
file_to_keep.append(path_string)

# Obtenir une liste de tous les fichiers dans le répertoire data
files = glob.glob(os.path.dirname(__file__) + "/data/*")

# Créer une liste de fichiers à supprimer
files_to_remove = []

# Vérifier chaque fichier et l'ajouter à la liste de suppression s'il n'est pas dans la liste des fichiers à conserver
for file_name in files:
beRemoved = True
for f_keep in file_to_keep:
if file_name == f_keep:
beRemoved = False
break
if beRemoved:
files_to_remove.append(file_name)

# Supprimer les fichiers de la liste de suppression
for file_name in files_to_remove:
os.remove(file_name)

# Point d'entrée du script
if __name__ == '__main__':
main()

</syntaxhighlight>

= Utilisation des programmes présentés ci-dessus =
Nous avons entrainé le programme grâce au logiciel NanoEdge Studio AI, à reconnaitre différentes fournitures scolaires.

Voici ci-dessous un exemple avec aucun objet, une colle et un stabilo.[[Fichier:20231220 173650.jpg|gauche|vignette|Aucun objet à reconnaitre]]
[[Fichier:20231220 173812.jpg|vignette|Un stabilo à reconnaitre]]
[[Fichier:20231220 173733.jpg|centre|vignette|Une colle à reconnaitre]]Nous po

SE5 ECEAI/eceai 2023/2024/Brenier-Nguyen

2024-01-20T14:18:59Z

Tbrenier : /* Utilisation des programmes présentés ci-dessus */

= Résumé de séance =
* Séance 1 :
** Création et configuration de la VM sur Chassiron
** Installation de NanoEdge
** Installation de STM32cube
** Installation de l'OS pour la Raspberry dans la carte micro SD
** Prise en main de Nanoedge, de nucléo et de STM32cube
** Début de réflexion sur l'application (métrologie)
*Séance 2:
**Mise en place du serveur python
**Mise en place du client python
**Test réussi de communication entre client et serveur via http
**Programmation de la carte nucléo pour transfert de valeur via liaison série
**Suite réflexion sur l'application (reconnaissance alphabet langue des signes, mouvement)
**Choix de l'application : reconnaissance d'objets appliqué aux fournitures scolaires
**Entraînement des modèles pour les différentes applications cités précédemment
**Finalement : entraînement à la reconnaissance d'objets de fournitures scolaires
*Séance 3:
**Entraînement d'un nouveau modèle.
**Écriture d'un programme permettant de récupérer les données du capteur et de les écrire dans un fichier.
*Séance 4 :
**Essai d'utilisation de la librairie créée grâce à Nanoedge.
**Amélioration du [[Code de récupération de donnée (sur la raspberry)|programme python]] permettant de récupérer les données du capteur.
***Création d'un fichier .txt afin de stocker les données du capteur toutes les minutes.
***Destruction automatique des fichiers de données ayant été crée il y a plus de 10 minutes.
**L’émulateur de la librairie ne fonctionne pas s'il est exécuté dans la raspberry... Nous l'exécutons désormais directement dans notre VM.
**Pour cela nous avons adapter notre programme python afin de récupérer les données à partir d'un json pour traiter ces données dans la VM.
***Création d'un fichier toutes les minutes (contenant au format json la date et les données au format csv)

=== <b>Code du serveur Python :</b> ===
<syntaxhighlight lang="python3">
from http.server import HTTPServer, BaseHTTPRequestHandler

import json

import socket

# Stocker les requ tes POST re ues

post_requests = []

class CustomHTTPHandler(BaseHTTPRequestHandler):

def do_GET(self):

if self.path == '/':

self.path = '/index.html'

if self.path == '/data':

self.send_response(200)

self.send_header('Content-type', 'application/json')

self.end_headers()

self.wfile.write(bytes(json.dumps(post_requests), 'utf-8'))

return

if self.path == '/index.html':

self.send_response(200)

self.send_header('Content-type', 'text/html')

self.end_headers()

# Cr er le contenu HTML avec les donn es POST

content = '<html><body><h1>Donn es POST:</h1><ul>'

for item in post_requests:

content += f'<li>{item}</li>'

content += '</ul></body></html>'

self.wfile.write(content.encode('utf-8'))

return

try:

file_to_open = open(self.path[1:]).read()

self.send_response(200)

self.send_header('Content-type', 'text/html')

self.end_headers()

self.wfile.write(bytes(file_to_open, 'utf-8'))

except FileNotFoundError:

self.send_error(404, 'File Not Found: %s' % self.path)

def do_POST(self):

content_length = int(self.headers['Content-Length'])

post_data = self.rfile.read(content_length).decode('utf-8')

# Ajouter les donn es POST la liste

post_requests.append(post_data)

# Envoyer une rponse HTTP

self.send_response(200)

self.end_headers()

self.wfile.write(b"POST request processed")

class HTTPServerV6(HTTPServer):

address_family = socket.AF_INET6

if __name__ == '__main__':

server_address = ('::', 8888) # ^icoute sur toutes les interfaces IPv6, p>

httpd = HTTPServerV6(server_address, CustomHTTPHandler)

print("Serveur actif sur le port", 8888)

httpd.serve_forever()
</syntaxhighlight>

=== '''Code du client Python :''' ===
<syntaxhighlight lang="python3">
import argparse
import requests
import json

def send_json_to_server(url, json_file):
# Charger les données CSV depuis le fichier spécifié
with open(json_file, 'r') as file:
data = json.load(file)

# En-têtes spécifiant que vous envoyez du CSV
headers = {'Content-Type': 'application/json'}

# Envoie de la requête HTTP POST avec les données
response = requests.post(url, data=json.dumps(data), headers=headers)

# Vérification de la réponse
if response.status_code == 200:
print('Requête envoyée avec succès!')
else:
print(f'Erreur {response.status_code}: {response.text}')

if __name__ == "__main__":
# Configurer les arguments en ligne de commande
parser = argparse.ArgumentParser(description='Client Python pour envoyer des JSON via HTTP.')
parser.add_argument('url', type=str, help='URL du serveur')
parser.add_argument('json_file', type=str, help='Chemin vers le fichier JSON à envoyer')

# Analyser les arguments
args = parser.parse_args()

# Appeler la fonction pour envoyer le JSON au serveur
send_json_to_server(args.url, args.json_file)
</syntaxhighlight>

=== '''Index permettant d'afficher le json de test que nous avons envoyé au serveur :''' ===
<syntaxhighlight lang="html">
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>Page d'Accueil</title>
</head>
<body>
<h1>Bienvenue sur Mon Serveur</h1>
<h2>Données POST reçues:</h2>
<ul id="data">

</ul>
</body>
</html>

</syntaxhighlight>

=== '''Capture montrant l'affichage d'un fichier json (sans aucun sens) envoyé au serveur depuis le client :''' ===

= Flash du capteur sur le logiciel STM32CubeIDE =
Le code ci-dessous est la fonction qui est appelé pour le traitement des capteurs. Nous avions décidé de définir le délimiteur de donnée avec un espace.
[[Fichier:CaptureIndexBrenierNguyen.png|centre|Démonstration du protocole HTTP]]

Ci-dessous, on retrouve de la ligne 8 à 12 la configuration du capteur que l'on a défini sur un quadrillage de 8 x 8.<syntaxhighlight lang="c" line="1">
static void MX_53L5A1_SimpleRanging_Process(void)
{
uint32_t Id;

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 */

/* 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);

if (status == BSP_ERROR_NONE)
{
//print_result(&Result);
print_result_IE(&Result);
}

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

HAL_Delay(POLLING_PERIOD);
}
}
</syntaxhighlight>Le code ci-dessous est la fonction qui nous permet d'afficher les données des capteurs via la liaison série.

On observe l'envoie des données avec un séparateur 'espace', puis lorsque les valeurs semblent incohérentes du point de vue du capteur, on envoie arbitrairement un -1 en sortie.

On obtient un jeu de donnée suivant le format : value espace value esapce .... value espace retour chariot (pour chaque lignes/quadrillage sur une ligne)<syntaxhighlight lang="c">
static void print_result_IE(RANGING_SENSOR_Result_t *Result)
{
int8_t j;
int8_t k;
int8_t l;
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("%ld ",(long)Result->ZoneResult[j+k].Distance[l]);
else
printf("%ld ", -1);
}
}
}
printf("\n");
}
</syntaxhighlight>

= Code de récupération de donnée (sur la raspberry) =
Nous avons le scénario suivant : le capteur qui envoie en continue les données de distance à la raspberry via la liaison série.

Nous avons donc écrit un script python afin de récupérer ces données, les formater dans un fichier format json dans le but de les envoyer sur la VM qui pourra traiter ces données avec l'émulateur obtenue via l'application NanoEdgeAI Studio.

Nous allons vous expliquez le script que nous avons réalisés :<syntaxhighlight lang="python3" line="1">
import serial
from threading import Thread, Event
from time import sleep
import os, sys, signal
import datetime
import glob

# Événement pour signaler l'arrêt des threads
interruptAllEvent = Event()

# Fonction de thread pour lire les données et les sauvegarder dans des fichiers
def serial_thread(ser: serial) -> None:
# Chemin du fichier pour les données initiales du capteur
# Ces données sont vouées à ne pas être utilisées
fileName_old = os.path.dirname(__file__) + "/data/sensor_data_start"

while (1):
if (interruptAllEvent.is_set()):
break

# Créer un nouveau fichier pour chaque minute avec l'horodatage actuel
fileName = os.path.dirname(__file__) + "/data/sensor_data_" + datetime.datetime.now().strftime("%d_%m_%Y__%H_%M_00") + ".json"

# Fermer le fichier de la minute précédente en ajoutant la parenthèse fermante
if (fileName_old != fileName):
with open(fileName_old, "a") as fichier:
fichier.write("\"}")

# Lire les données du port série
string = str(ser.readline(), encoding='utf-8')

# Ouvrir le fichier de la minute actuelle et écrire les données
with open(fileName, "a") as fichier:
# S'il s'agit d'une nouvelle minute, commencer un nouvel objet JSON
if (fileName_old != fileName):
fileName_old = fileName
fichier.write("{\"date\":\""+datetime.datetime.now().strftime("%d/%m/%Y-%H:%M:00")+"\",\"csv_file\":\"")

# Écrire les données dans le fichier
fichier.write(string)

# Gestionnaire de signal pour définir l'événement d'interruption lors d'une interruption clavier (Ctrl+C)
def signal_handler(sig, frame):
interruptAllEvent.set()
return

# Fonction principale
def main() -> None:
# Créer un objet pour la communication série
ser = serial.Serial('/dev/ttyACM0', 460800)

# Créer un thread pour la communication série
thread = Thread(target=serial_thread, args=(ser,))

# Démarrer le thread de communication série
thread.start()

# Mettre en place le gestionnaire de signal pour les événements d'interruption (Ctrl+C)
signal.signal(signal.SIGINT, signal_handler)

# Attendre pendant 5 secondes et supprimer le fichier de données initial du capteur
sleep(5)
os.remove(os.path.dirname(__file__) + "/data/sensor_data_start")

while (1):
# Vérifier si l'événement d'interruption est défini
if interruptAllEvent.is_set():
# Attendre que le thread série se termine, puis sortir de la boucle
thread.join()
break

sleep(5)

# Ajuster les valeurs de minute et d'heure pour l'heure précédente
minute = datetime.datetime.now().minute - 1
hours = datetime.datetime.now().hour
if (minute < 0):
minute = minute + 60
hours = hours - 1

# On modifie tout les \n du fichier json afin que son transfert et sa réception vers le serveur
# soit du bon format. On protège donc tout les \n du fichier avant son envoie.
try:
# Lire et modifier le contenu du fichier de la minute précédente
with open(os.path.dirname(__file__) + "/data/sensor_data_" + datetime.datetime.now().strftime("%d_%m_%Y__") + str(hours) + "_" + str(minute) + "_00.json", "r+") as fichier:
line = fichier.read()
str(line).replace('\n','\\\n')
fichier.write(line)
except FileNotFoundError:
sleep(60)

# Créer une liste de chemins de fichiers pour les 10 dernières minutes
# Tout les autres sont amenés à être supprimés. Dans le but de préserver de la mémoire de stockage
file_to_keep = []
for i in range(0,10):
minute = datetime.datetime.now().minute - i
hours = datetime.datetime.now().hour
if (minute < 0):
minute = minute + 60
hours = hours - 1
path_string = os.path.dirname(__file__) + "/data/sensor_data_" + datetime.datetime.now().strftime("%d_%m_%Y__") + str(hours) + "_" + str(minute) + "_00.json"
file_to_keep.append(path_string)

# Obtenir une liste de tous les fichiers dans le répertoire data
files = glob.glob(os.path.dirname(__file__) + "/data/*")

# Créer une liste de fichiers à supprimer
files_to_remove = []

# Vérifier chaque fichier et l'ajouter à la liste de suppression s'il n'est pas dans la liste des fichiers à conserver
for file_name in files:
beRemoved = True
for f_keep in file_to_keep:
if file_name == f_keep:
beRemoved = False
break
if beRemoved:
files_to_remove.append(file_name)

# Supprimer les fichiers de la liste de suppression
for file_name in files_to_remove:
os.remove(file_name)

# Point d'entrée du script
if __name__ == '__main__':
main()

</syntaxhighlight>

= Utilisation des programmes présentés ci-dessus =
Nous avons entrainé le programme pour reconnaitre[[Fichier:20231220 173650.jpg|gauche|vignette|Aucun objet à reconnaitre]]
[[Fichier:20231220 173812.jpg|vignette|Un stabilo à reconnaitre]]
[[Fichier:20231220 173733.jpg|centre|vignette|Une colle à reconnaitre]]

SE5 ECEAI/eceai 2023/2024/Brenier-Nguyen

2024-01-20T14:13:03Z

Tbrenier : /* Code de récupération de donnée (sur la raspberry) */

= Résumé de séance =
* Séance 1 :
** Création et configuration de la VM sur Chassiron
** Installation de NanoEdge
** Installation de STM32cube
** Installation de l'OS pour la Raspberry dans la carte micro SD
** Prise en main de Nanoedge, de nucléo et de STM32cube
** Début de réflexion sur l'application (métrologie)
*Séance 2:
**Mise en place du serveur python
**Mise en place du client python
**Test réussi de communication entre client et serveur via http
**Programmation de la carte nucléo pour transfert de valeur via liaison série
**Suite réflexion sur l'application (reconnaissance alphabet langue des signes, mouvement)
**Choix de l'application : reconnaissance d'objets appliqué aux fournitures scolaires
**Entraînement des modèles pour les différentes applications cités précédemment
**Finalement : entraînement à la reconnaissance d'objets de fournitures scolaires
*Séance 3:
**Entraînement d'un nouveau modèle.
**Écriture d'un programme permettant de récupérer les données du capteur et de les écrire dans un fichier.
*Séance 4 :
**Essai d'utilisation de la librairie créée grâce à Nanoedge.
**Amélioration du [[Code de récupération de donnée (sur la raspberry)|programme python]] permettant de récupérer les données du capteur.
***Création d'un fichier .txt afin de stocker les données du capteur toutes les minutes.
***Destruction automatique des fichiers de données ayant été crée il y a plus de 10 minutes.
**L’émulateur de la librairie ne fonctionne pas s'il est exécuté dans la raspberry... Nous l'exécutons désormais directement dans notre VM.
**Pour cela nous avons adapter notre programme python afin de récupérer les données à partir d'un json pour traiter ces données dans la VM.
***Création d'un fichier toutes les minutes (contenant au format json la date et les données au format csv)

=== <b>Code du serveur Python :</b> ===
<syntaxhighlight lang="python3">
from http.server import HTTPServer, BaseHTTPRequestHandler

import json

import socket

# Stocker les requ tes POST re ues

post_requests = []

class CustomHTTPHandler(BaseHTTPRequestHandler):

def do_GET(self):

if self.path == '/':

self.path = '/index.html'

if self.path == '/data':

self.send_response(200)

self.send_header('Content-type', 'application/json')

self.end_headers()

self.wfile.write(bytes(json.dumps(post_requests), 'utf-8'))

return

if self.path == '/index.html':

self.send_response(200)

self.send_header('Content-type', 'text/html')

self.end_headers()

# Cr er le contenu HTML avec les donn es POST

content = '<html><body><h1>Donn es POST:</h1><ul>'

for item in post_requests:

content += f'<li>{item}</li>'

content += '</ul></body></html>'

self.wfile.write(content.encode('utf-8'))

return

try:

file_to_open = open(self.path[1:]).read()

self.send_response(200)

self.send_header('Content-type', 'text/html')

self.end_headers()

self.wfile.write(bytes(file_to_open, 'utf-8'))

except FileNotFoundError:

self.send_error(404, 'File Not Found: %s' % self.path)

def do_POST(self):

content_length = int(self.headers['Content-Length'])

post_data = self.rfile.read(content_length).decode('utf-8')

# Ajouter les donn es POST la liste

post_requests.append(post_data)

# Envoyer une rponse HTTP

self.send_response(200)

self.end_headers()

self.wfile.write(b"POST request processed")

class HTTPServerV6(HTTPServer):

address_family = socket.AF_INET6

if __name__ == '__main__':

server_address = ('::', 8888) # ^icoute sur toutes les interfaces IPv6, p>

httpd = HTTPServerV6(server_address, CustomHTTPHandler)

print("Serveur actif sur le port", 8888)

httpd.serve_forever()
</syntaxhighlight>

=== '''Code du client Python :''' ===
<syntaxhighlight lang="python3">
import argparse
import requests
import json

def send_json_to_server(url, json_file):
# Charger les données CSV depuis le fichier spécifié
with open(json_file, 'r') as file:
data = json.load(file)

# En-têtes spécifiant que vous envoyez du CSV
headers = {'Content-Type': 'application/json'}

# Envoie de la requête HTTP POST avec les données
response = requests.post(url, data=json.dumps(data), headers=headers)

# Vérification de la réponse
if response.status_code == 200:
print('Requête envoyée avec succès!')
else:
print(f'Erreur {response.status_code}: {response.text}')

if __name__ == "__main__":
# Configurer les arguments en ligne de commande
parser = argparse.ArgumentParser(description='Client Python pour envoyer des JSON via HTTP.')
parser.add_argument('url', type=str, help='URL du serveur')
parser.add_argument('json_file', type=str, help='Chemin vers le fichier JSON à envoyer')

# Analyser les arguments
args = parser.parse_args()

# Appeler la fonction pour envoyer le JSON au serveur
send_json_to_server(args.url, args.json_file)
</syntaxhighlight>

=== '''Index permettant d'afficher le json de test que nous avons envoyé au serveur :''' ===
<syntaxhighlight lang="html">
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>Page d'Accueil</title>
</head>
<body>
<h1>Bienvenue sur Mon Serveur</h1>
<h2>Données POST reçues:</h2>
<ul id="data">

</ul>
</body>
</html>

</syntaxhighlight>

=== '''Capture montrant l'affichage d'un fichier json (sans aucun sens) envoyé au serveur depuis le client :''' ===

= Flash du capteur sur le logiciel STM32CubeIDE =
Le code ci-dessous est la fonction qui est appelé pour le traitement des capteurs. Nous avions décidé de définir le délimiteur de donnée avec un espace.
[[Fichier:CaptureIndexBrenierNguyen.png|centre|Démonstration du protocole HTTP]]

Ci-dessous, on retrouve de la ligne 8 à 12 la configuration du capteur que l'on a défini sur un quadrillage de 8 x 8.<syntaxhighlight lang="c" line="1">
static void MX_53L5A1_SimpleRanging_Process(void)
{
uint32_t Id;

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 */

/* 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);

if (status == BSP_ERROR_NONE)
{
//print_result(&Result);
print_result_IE(&Result);
}

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

HAL_Delay(POLLING_PERIOD);
}
}
</syntaxhighlight>Le code ci-dessous est la fonction qui nous permet d'afficher les données des capteurs via la liaison série.

On observe l'envoie des données avec un séparateur 'espace', puis lorsque les valeurs semblent incohérentes du point de vue du capteur, on envoie arbitrairement un -1 en sortie.

On obtient un jeu de donnée suivant le format : value espace value esapce .... value espace retour chariot (pour chaque lignes/quadrillage sur une ligne)<syntaxhighlight lang="c">
static void print_result_IE(RANGING_SENSOR_Result_t *Result)
{
int8_t j;
int8_t k;
int8_t l;
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("%ld ",(long)Result->ZoneResult[j+k].Distance[l]);
else
printf("%ld ", -1);
}
}
}
printf("\n");
}
</syntaxhighlight>

= Code de récupération de donnée (sur la raspberry) =
Nous avons le scénario suivant : le capteur qui envoie en continue les données de distance à la raspberry via la liaison série.

Nous avons donc écrit un script python afin de récupérer ces données, les formater dans un fichier format json dans le but de les envoyer sur la VM qui pourra traiter ces données avec l'émulateur obtenue via l'application NanoEdgeAI Studio.

Nous allons vous expliquez le script que nous avons réalisés :<syntaxhighlight lang="python3" line="1">
import serial
from threading import Thread, Event
from time import sleep
import os, sys, signal
import datetime
import glob

# Événement pour signaler l'arrêt des threads
interruptAllEvent = Event()

# Fonction de thread pour lire les données et les sauvegarder dans des fichiers
def serial_thread(ser: serial) -> None:
# Chemin du fichier pour les données initiales du capteur
# Ces données sont vouées à ne pas être utilisées
fileName_old = os.path.dirname(__file__) + "/data/sensor_data_start"

while (1):
if (interruptAllEvent.is_set()):
break

# Créer un nouveau fichier pour chaque minute avec l'horodatage actuel
fileName = os.path.dirname(__file__) + "/data/sensor_data_" + datetime.datetime.now().strftime("%d_%m_%Y__%H_%M_00") + ".json"

# Fermer le fichier de la minute précédente en ajoutant la parenthèse fermante
if (fileName_old != fileName):
with open(fileName_old, "a") as fichier:
fichier.write("\"}")

# Lire les données du port série
string = str(ser.readline(), encoding='utf-8')

# Ouvrir le fichier de la minute actuelle et écrire les données
with open(fileName, "a") as fichier:
# S'il s'agit d'une nouvelle minute, commencer un nouvel objet JSON
if (fileName_old != fileName):
fileName_old = fileName
fichier.write("{\"date\":\""+datetime.datetime.now().strftime("%d/%m/%Y-%H:%M:00")+"\",\"csv_file\":\"")

# Écrire les données dans le fichier
fichier.write(string)

# Gestionnaire de signal pour définir l'événement d'interruption lors d'une interruption clavier (Ctrl+C)
def signal_handler(sig, frame):
interruptAllEvent.set()
return

# Fonction principale
def main() -> None:
# Créer un objet pour la communication série
ser = serial.Serial('/dev/ttyACM0', 460800)

# Créer un thread pour la communication série
thread = Thread(target=serial_thread, args=(ser,))

# Démarrer le thread de communication série
thread.start()

# Mettre en place le gestionnaire de signal pour les événements d'interruption (Ctrl+C)
signal.signal(signal.SIGINT, signal_handler)

# Attendre pendant 5 secondes et supprimer le fichier de données initial du capteur
sleep(5)
os.remove(os.path.dirname(__file__) + "/data/sensor_data_start")

while (1):
# Vérifier si l'événement d'interruption est défini
if interruptAllEvent.is_set():
# Attendre que le thread série se termine, puis sortir de la boucle
thread.join()
break

sleep(5)

# Ajuster les valeurs de minute et d'heure pour l'heure précédente
minute = datetime.datetime.now().minute - 1
hours = datetime.datetime.now().hour
if (minute < 0):
minute = minute + 60
hours = hours - 1

# On modifie tout les \n du fichier json afin que son transfert et sa réception vers le serveur
# soit du bon format. On protège donc tout les \n du fichier avant son envoie.
try:
# Lire et modifier le contenu du fichier de la minute précédente
with open(os.path.dirname(__file__) + "/data/sensor_data_" + datetime.datetime.now().strftime("%d_%m_%Y__") + str(hours) + "_" + str(minute) + "_00.json", "r+") as fichier:
line = fichier.read()
str(line).replace('\n','\\\n')
fichier.write(line)
except FileNotFoundError:
sleep(60)

# Créer une liste de chemins de fichiers pour les 10 dernières minutes
# Tout les autres sont amenés à être supprimés. Dans le but de préserver de la mémoire de stockage
file_to_keep = []
for i in range(0,10):
minute = datetime.datetime.now().minute - i
hours = datetime.datetime.now().hour
if (minute < 0):
minute = minute + 60
hours = hours - 1
path_string = os.path.dirname(__file__) + "/data/sensor_data_" + datetime.datetime.now().strftime("%d_%m_%Y__") + str(hours) + "_" + str(minute) + "_00.json"
file_to_keep.append(path_string)

# Obtenir une liste de tous les fichiers dans le répertoire data
files = glob.glob(os.path.dirname(__file__) + "/data/*")

# Créer une liste de fichiers à supprimer
files_to_remove = []

# Vérifier chaque fichier et l'ajouter à la liste de suppression s'il n'est pas dans la liste des fichiers à conserver
for file_name in files:
beRemoved = True
for f_keep in file_to_keep:
if file_name == f_keep:
beRemoved = False
break
if beRemoved:
files_to_remove.append(file_name)

# Supprimer les fichiers de la liste de suppression
for file_name in files_to_remove:
os.remove(file_name)

# Point d'entrée du script
if __name__ == '__main__':
main()

</syntaxhighlight>

= Utilisation des programmes présentés ci-dessus =
[[Fichier:20231220 173650.jpg|gauche|vignette|Aucun objet à reconnaitre]]
[[Fichier:20231220 173812.jpg|vignette|Un stabilo à reconnaitre]]
[[Fichier:20231220 173733.jpg|centre|vignette|Une colle à reconnaitre]]

SE5 ECEAI/eceai 2023/2024/Brenier-Nguyen

2024-01-20T14:12:28Z

Tbrenier : /* Utilisation des programmes présentés ci-dessus */

= Résumé de séance =
* Séance 1 :
** Création et configuration de la VM sur Chassiron
** Installation de NanoEdge
** Installation de STM32cube
** Installation de l'OS pour la Raspberry dans la carte micro SD
** Prise en main de Nanoedge, de nucléo et de STM32cube
** Début de réflexion sur l'application (métrologie)
*Séance 2:
**Mise en place du serveur python
**Mise en place du client python
**Test réussi de communication entre client et serveur via http
**Programmation de la carte nucléo pour transfert de valeur via liaison série
**Suite réflexion sur l'application (reconnaissance alphabet langue des signes, mouvement)
**Choix de l'application : reconnaissance d'objets appliqué aux fournitures scolaires
**Entraînement des modèles pour les différentes applications cités précédemment
**Finalement : entraînement à la reconnaissance d'objets de fournitures scolaires
*Séance 3:
**Entraînement d'un nouveau modèle.
**Écriture d'un programme permettant de récupérer les données du capteur et de les écrire dans un fichier.
*Séance 4 :
**Essai d'utilisation de la librairie créée grâce à Nanoedge.
**Amélioration du [[Code de récupération de donnée (sur la raspberry)|programme python]] permettant de récupérer les données du capteur.
***Création d'un fichier .txt afin de stocker les données du capteur toutes les minutes.
***Destruction automatique des fichiers de données ayant été crée il y a plus de 10 minutes.
**L’émulateur de la librairie ne fonctionne pas s'il est exécuté dans la raspberry... Nous l'exécutons désormais directement dans notre VM.
**Pour cela nous avons adapter notre programme python afin de récupérer les données à partir d'un json pour traiter ces données dans la VM.
***Création d'un fichier toutes les minutes (contenant au format json la date et les données au format csv)

=== <b>Code du serveur Python :</b> ===
<syntaxhighlight lang="python3">
from http.server import HTTPServer, BaseHTTPRequestHandler

import json

import socket

# Stocker les requ tes POST re ues

post_requests = []

class CustomHTTPHandler(BaseHTTPRequestHandler):

def do_GET(self):

if self.path == '/':

self.path = '/index.html'

if self.path == '/data':

self.send_response(200)

self.send_header('Content-type', 'application/json')

self.end_headers()

self.wfile.write(bytes(json.dumps(post_requests), 'utf-8'))

return

if self.path == '/index.html':

self.send_response(200)

self.send_header('Content-type', 'text/html')

self.end_headers()

# Cr er le contenu HTML avec les donn es POST

content = '<html><body><h1>Donn es POST:</h1><ul>'

for item in post_requests:

content += f'<li>{item}</li>'

content += '</ul></body></html>'

self.wfile.write(content.encode('utf-8'))

return

try:

file_to_open = open(self.path[1:]).read()

self.send_response(200)

self.send_header('Content-type', 'text/html')

self.end_headers()

self.wfile.write(bytes(file_to_open, 'utf-8'))

except FileNotFoundError:

self.send_error(404, 'File Not Found: %s' % self.path)

def do_POST(self):

content_length = int(self.headers['Content-Length'])

post_data = self.rfile.read(content_length).decode('utf-8')

# Ajouter les donn es POST la liste

post_requests.append(post_data)

# Envoyer une rponse HTTP

self.send_response(200)

self.end_headers()

self.wfile.write(b"POST request processed")

class HTTPServerV6(HTTPServer):

address_family = socket.AF_INET6

if __name__ == '__main__':

server_address = ('::', 8888) # ^icoute sur toutes les interfaces IPv6, p>

httpd = HTTPServerV6(server_address, CustomHTTPHandler)

print("Serveur actif sur le port", 8888)

httpd.serve_forever()
</syntaxhighlight>

=== '''Code du client Python :''' ===
<syntaxhighlight lang="python3">
import argparse
import requests
import json

def send_json_to_server(url, json_file):
# Charger les données CSV depuis le fichier spécifié
with open(json_file, 'r') as file:
data = json.load(file)

# En-têtes spécifiant que vous envoyez du CSV
headers = {'Content-Type': 'application/json'}

# Envoie de la requête HTTP POST avec les données
response = requests.post(url, data=json.dumps(data), headers=headers)

# Vérification de la réponse
if response.status_code == 200:
print('Requête envoyée avec succès!')
else:
print(f'Erreur {response.status_code}: {response.text}')

if __name__ == "__main__":
# Configurer les arguments en ligne de commande
parser = argparse.ArgumentParser(description='Client Python pour envoyer des JSON via HTTP.')
parser.add_argument('url', type=str, help='URL du serveur')
parser.add_argument('json_file', type=str, help='Chemin vers le fichier JSON à envoyer')

# Analyser les arguments
args = parser.parse_args()

# Appeler la fonction pour envoyer le JSON au serveur
send_json_to_server(args.url, args.json_file)
</syntaxhighlight>

=== '''Index permettant d'afficher le json de test que nous avons envoyé au serveur :''' ===
<syntaxhighlight lang="html">
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>Page d'Accueil</title>
</head>
<body>
<h1>Bienvenue sur Mon Serveur</h1>
<h2>Données POST reçues:</h2>
<ul id="data">

</ul>
</body>
</html>

</syntaxhighlight>

=== '''Capture montrant l'affichage d'un fichier json (sans aucun sens) envoyé au serveur depuis le client :''' ===

= Flash du capteur sur le logiciel STM32CubeIDE =
Le code ci-dessous est la fonction qui est appelé pour le traitement des capteurs. Nous avions décidé de définir le délimiteur de donnée avec un espace.
[[Fichier:CaptureIndexBrenierNguyen.png|centre|Démonstration du protocole HTTP]]

Ci-dessous, on retrouve de la ligne 8 à 12 la configuration du capteur que l'on a défini sur un quadrillage de 8 x 8.<syntaxhighlight lang="c" line="1">
static void MX_53L5A1_SimpleRanging_Process(void)
{
uint32_t Id;

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 */

/* 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);

if (status == BSP_ERROR_NONE)
{
//print_result(&Result);
print_result_IE(&Result);
}

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

HAL_Delay(POLLING_PERIOD);
}
}
</syntaxhighlight>Le code ci-dessous est la fonction qui nous permet d'afficher les données des capteurs via la liaison série.

On observe l'envoie des données avec un séparateur 'espace', puis lorsque les valeurs semblent incohérentes du point de vue du capteur, on envoie arbitrairement un -1 en sortie.

On obtient un jeu de donnée suivant le format : value espace value esapce .... value espace retour chariot (pour chaque lignes/quadrillage sur une ligne)<syntaxhighlight lang="c">
static void print_result_IE(RANGING_SENSOR_Result_t *Result)
{
int8_t j;
int8_t k;
int8_t l;
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("%ld ",(long)Result->ZoneResult[j+k].Distance[l]);
else
printf("%ld ", -1);
}
}
}
printf("\n");
}
</syntaxhighlight>

= Code de récupération de donnée (sur la raspberry) =
Nous avons le scénario suivant : le capteur qui envoie en continue les données de distance à la raspberry via la liaison série.

Nous avons donc écrit un script python afin de récupérer ces données, les formater dans un fichier format json dans le but de les envoyer sur la VM qui pourra traiter ces données avec l'émulateur obtenue via l'application NanoEdgeAI Studio.

Nous allons vous expliquez le script que nous avons réalisés :<syntaxhighlight lang="python3" line="1">
import serial
from threading import Thread, Event
from time import sleep
import os, sys, signal
import datetime
import glob

# Événement pour signaler l'arrêt des threads
interruptAllEvent = Event()

# Fonction de thread pour lire les données et les sauvegarder dans des fichiers
def serial_thread(ser: serial) -> None:
# Chemin du fichier pour les données initiales du capteur
# Ces données sont vouées à ne pas être utilisées
fileName_old = os.path.dirname(__file__) + "/data/sensor_data_start"

while (1):
if (interruptAllEvent.is_set()):
break

# Créer un nouveau fichier pour chaque minute avec l'horodatage actuel
fileName = os.path.dirname(__file__) + "/data/sensor_data_" + datetime.datetime.now().strftime("%d_%m_%Y__%H_%M_00") + ".json"

# Fermer le fichier de la minute précédente en ajoutant la parenthèse fermante
if (fileName_old != fileName):
with open(fileName_old, "a") as fichier:
fichier.write("\"}")

# Lire les données du port série
string = str(ser.readline(), encoding='utf-8')

# Ouvrir le fichier de la minute actuelle et écrire les données
with open(fileName, "a") as fichier:
# S'il s'agit d'une nouvelle minute, commencer un nouvel objet JSON
if (fileName_old != fileName):
fileName_old = fileName
fichier.write("{\"date\":\""+datetime.datetime.now().strftime("%d/%m/%Y-%H:%M:00")+"\",\"csv_file\":\"")

# Écrire les données dans le fichier
fichier.write(string)

# Gestionnaire de signal pour définir l'événement d'interruption lors d'une interruption clavier (Ctrl+C)
def signal_handler(sig, frame):
interruptAllEvent.set()
return

# Fonction principale
def main() -> None:
# Créer un objet pour la communication série
ser = serial.Serial('/dev/ttyACM0', 460800)

# Créer un thread pour la communication série
thread = Thread(target=serial_thread, args=(ser,))

# Démarrer le thread de communication série
thread.start()

# Mettre en place le gestionnaire de signal pour les événements d'interruption (Ctrl+C)
signal.signal(signal.SIGINT, signal_handler)

# Attendre pendant 5 secondes et supprimer le fichier de données initial du capteur
sleep(5)
os.remove(os.path.dirname(__file__) + "/data/sensor_data_start")

while (1):
# Vérifier si l'événement d'interruption est défini
if interruptAllEvent.is_set():
# Attendre que le thread série se termine, puis sortir de la boucle
thread.join()
break

sleep(5)

# Ajuster les valeurs de minute et d'heure pour l'heure précédente
minute = datetime.datetime.now().minute - 1
hours = datetime.datetime.now().hour
if (minute < 0):
minute = minute + 60
hours = hours - 1

# On modifie tout les \n du fichier json afin que son transfert et sa réception vers le serveur
# soit du bon format. On protège donc tout les \n du fichier avant son envoie.
try:
# Lire et modifier le contenu du fichier de la minute précédente
with open(os.path.dirname(__file__) + "/data/sensor_data_" + datetime.datetime.now().strftime("%d_%m_%Y__") + str(hours) + "_" + str(minute) + "_00.json", "r+") as fichier:
line = fichier.read()
str(line).replace('\n','\\\n')
fichier.write(line)
except FileNotFoundError:
sleep(60)

# Créer une liste de chemins de fichiers pour les 10 dernières minutes
# Tout les autres sont amenés à être supprimés. Dans le but de préserver de la mémoire de stockage
file_to_keep = []
for i in range(0,10):
minute = datetime.datetime.now().minute - i
hours = datetime.datetime.now().hour
if (minute < 0):
minute = minute + 60
hours = hours - 1
path_string = os.path.dirname(__file__) + "/data/sensor_data_" + datetime.datetime.now().strftime("%d_%m_%Y__") + str(hours) + "_" + str(minute) + "_00.json"
file_to_keep.append(path_string)

# Obtenir une liste de tous les fichiers dans le répertoire data
files = glob.glob(os.path.dirname(__file__) + "/data/*")

# Créer une liste de fichiers à supprimer
files_to_remove = []

# Vérifier chaque fichier et l'ajouter à la liste de suppression s'il n'est pas dans la liste des fichiers à conserver
for file_name in files:
beRemoved = True
for f_keep in file_to_keep:
if file_name == f_keep:
beRemoved = False
break
if beRemoved:
files_to_remove.append(file_name)

# Supprimer les fichiers de la liste de suppression
for file_name in files_to_remove:
os.remove(file_name)

# Point d'entrée du script
if __name__ == '__main__':
main()

</syntaxhighlight>

== Utilisation des programmes présentés ci-dessus ==
[[Fichier:20231220 173650.jpg|gauche|vignette|Aucun objet à reconnaitre]]
[[Fichier:20231220 173812.jpg|vignette|Un stabilo à reconnaitre]]
[[Fichier:20231220 173733.jpg|centre|vignette|Une colle à reconnaitre]]

SE5 ECEAI/eceai 2023/2024/Brenier-Nguyen

2024-01-20T14:11:58Z

Tbrenier : /* Utilisation des programmes présentés ci-dessus */

= Résumé de séance =
* Séance 1 :
** Création et configuration de la VM sur Chassiron
** Installation de NanoEdge
** Installation de STM32cube
** Installation de l'OS pour la Raspberry dans la carte micro SD
** Prise en main de Nanoedge, de nucléo et de STM32cube
** Début de réflexion sur l'application (métrologie)
*Séance 2:
**Mise en place du serveur python
**Mise en place du client python
**Test réussi de communication entre client et serveur via http
**Programmation de la carte nucléo pour transfert de valeur via liaison série
**Suite réflexion sur l'application (reconnaissance alphabet langue des signes, mouvement)
**Choix de l'application : reconnaissance d'objets appliqué aux fournitures scolaires
**Entraînement des modèles pour les différentes applications cités précédemment
**Finalement : entraînement à la reconnaissance d'objets de fournitures scolaires
*Séance 3:
**Entraînement d'un nouveau modèle.
**Écriture d'un programme permettant de récupérer les données du capteur et de les écrire dans un fichier.
*Séance 4 :
**Essai d'utilisation de la librairie créée grâce à Nanoedge.
**Amélioration du [[Code de récupération de donnée (sur la raspberry)|programme python]] permettant de récupérer les données du capteur.
***Création d'un fichier .txt afin de stocker les données du capteur toutes les minutes.
***Destruction automatique des fichiers de données ayant été crée il y a plus de 10 minutes.
**L’émulateur de la librairie ne fonctionne pas s'il est exécuté dans la raspberry... Nous l'exécutons désormais directement dans notre VM.
**Pour cela nous avons adapter notre programme python afin de récupérer les données à partir d'un json pour traiter ces données dans la VM.
***Création d'un fichier toutes les minutes (contenant au format json la date et les données au format csv)

=== <b>Code du serveur Python :</b> ===
<syntaxhighlight lang="python3">
from http.server import HTTPServer, BaseHTTPRequestHandler

import json

import socket

# Stocker les requ tes POST re ues

post_requests = []

class CustomHTTPHandler(BaseHTTPRequestHandler):

def do_GET(self):

if self.path == '/':

self.path = '/index.html'

if self.path == '/data':

self.send_response(200)

self.send_header('Content-type', 'application/json')

self.end_headers()

self.wfile.write(bytes(json.dumps(post_requests), 'utf-8'))

return

if self.path == '/index.html':

self.send_response(200)

self.send_header('Content-type', 'text/html')

self.end_headers()

# Cr er le contenu HTML avec les donn es POST

content = '<html><body><h1>Donn es POST:</h1><ul>'

for item in post_requests:

content += f'<li>{item}</li>'

content += '</ul></body></html>'

self.wfile.write(content.encode('utf-8'))

return

try:

file_to_open = open(self.path[1:]).read()

self.send_response(200)

self.send_header('Content-type', 'text/html')

self.end_headers()

self.wfile.write(bytes(file_to_open, 'utf-8'))

except FileNotFoundError:

self.send_error(404, 'File Not Found: %s' % self.path)

def do_POST(self):

content_length = int(self.headers['Content-Length'])

post_data = self.rfile.read(content_length).decode('utf-8')

# Ajouter les donn es POST la liste

post_requests.append(post_data)

# Envoyer une rponse HTTP

self.send_response(200)

self.end_headers()

self.wfile.write(b"POST request processed")

class HTTPServerV6(HTTPServer):

address_family = socket.AF_INET6

if __name__ == '__main__':

server_address = ('::', 8888) # ^icoute sur toutes les interfaces IPv6, p>

httpd = HTTPServerV6(server_address, CustomHTTPHandler)

print("Serveur actif sur le port", 8888)

httpd.serve_forever()
</syntaxhighlight>

=== '''Code du client Python :''' ===
<syntaxhighlight lang="python3">
import argparse
import requests
import json

def send_json_to_server(url, json_file):
# Charger les données CSV depuis le fichier spécifié
with open(json_file, 'r') as file:
data = json.load(file)

# En-têtes spécifiant que vous envoyez du CSV
headers = {'Content-Type': 'application/json'}

# Envoie de la requête HTTP POST avec les données
response = requests.post(url, data=json.dumps(data), headers=headers)

# Vérification de la réponse
if response.status_code == 200:
print('Requête envoyée avec succès!')
else:
print(f'Erreur {response.status_code}: {response.text}')

if __name__ == "__main__":
# Configurer les arguments en ligne de commande
parser = argparse.ArgumentParser(description='Client Python pour envoyer des JSON via HTTP.')
parser.add_argument('url', type=str, help='URL du serveur')
parser.add_argument('json_file', type=str, help='Chemin vers le fichier JSON à envoyer')

# Analyser les arguments
args = parser.parse_args()

# Appeler la fonction pour envoyer le JSON au serveur
send_json_to_server(args.url, args.json_file)
</syntaxhighlight>

=== '''Index permettant d'afficher le json de test que nous avons envoyé au serveur :''' ===
<syntaxhighlight lang="html">
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>Page d'Accueil</title>
</head>
<body>
<h1>Bienvenue sur Mon Serveur</h1>
<h2>Données POST reçues:</h2>
<ul id="data">

</ul>
</body>
</html>

</syntaxhighlight>

=== '''Capture montrant l'affichage d'un fichier json (sans aucun sens) envoyé au serveur depuis le client :''' ===

= Flash du capteur sur le logiciel STM32CubeIDE =
Le code ci-dessous est la fonction qui est appelé pour le traitement des capteurs. Nous avions décidé de définir le délimiteur de donnée avec un espace.
[[Fichier:CaptureIndexBrenierNguyen.png|centre|Démonstration du protocole HTTP]]

Ci-dessous, on retrouve de la ligne 8 à 12 la configuration du capteur que l'on a défini sur un quadrillage de 8 x 8.<syntaxhighlight lang="c" line="1">
static void MX_53L5A1_SimpleRanging_Process(void)
{
uint32_t Id;

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 */

/* 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);

if (status == BSP_ERROR_NONE)
{
//print_result(&Result);
print_result_IE(&Result);
}

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

HAL_Delay(POLLING_PERIOD);
}
}
</syntaxhighlight>Le code ci-dessous est la fonction qui nous permet d'afficher les données des capteurs via la liaison série.

On observe l'envoie des données avec un séparateur 'espace', puis lorsque les valeurs semblent incohérentes du point de vue du capteur, on envoie arbitrairement un -1 en sortie.

On obtient un jeu de donnée suivant le format : value espace value esapce .... value espace retour chariot (pour chaque lignes/quadrillage sur une ligne)<syntaxhighlight lang="c">
static void print_result_IE(RANGING_SENSOR_Result_t *Result)
{
int8_t j;
int8_t k;
int8_t l;
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("%ld ",(long)Result->ZoneResult[j+k].Distance[l]);
else
printf("%ld ", -1);
}
}
}
printf("\n");
}
</syntaxhighlight>

= Code de récupération de donnée (sur la raspberry) =
Nous avons le scénario suivant : le capteur qui envoie en continue les données de distance à la raspberry via la liaison série.

Nous avons donc écrit un script python afin de récupérer ces données, les formater dans un fichier format json dans le but de les envoyer sur la VM qui pourra traiter ces données avec l'émulateur obtenue via l'application NanoEdgeAI Studio.

Nous allons vous expliquez le script que nous avons réalisés :<syntaxhighlight lang="python3" line="1">
import serial
from threading import Thread, Event
from time import sleep
import os, sys, signal
import datetime
import glob

# Événement pour signaler l'arrêt des threads
interruptAllEvent = Event()

# Fonction de thread pour lire les données et les sauvegarder dans des fichiers
def serial_thread(ser: serial) -> None:
# Chemin du fichier pour les données initiales du capteur
# Ces données sont vouées à ne pas être utilisées
fileName_old = os.path.dirname(__file__) + "/data/sensor_data_start"

while (1):
if (interruptAllEvent.is_set()):
break

# Créer un nouveau fichier pour chaque minute avec l'horodatage actuel
fileName = os.path.dirname(__file__) + "/data/sensor_data_" + datetime.datetime.now().strftime("%d_%m_%Y__%H_%M_00") + ".json"

# Fermer le fichier de la minute précédente en ajoutant la parenthèse fermante
if (fileName_old != fileName):
with open(fileName_old, "a") as fichier:
fichier.write("\"}")

# Lire les données du port série
string = str(ser.readline(), encoding='utf-8')

# Ouvrir le fichier de la minute actuelle et écrire les données
with open(fileName, "a") as fichier:
# S'il s'agit d'une nouvelle minute, commencer un nouvel objet JSON
if (fileName_old != fileName):
fileName_old = fileName
fichier.write("{\"date\":\""+datetime.datetime.now().strftime("%d/%m/%Y-%H:%M:00")+"\",\"csv_file\":\"")

# Écrire les données dans le fichier
fichier.write(string)

# Gestionnaire de signal pour définir l'événement d'interruption lors d'une interruption clavier (Ctrl+C)
def signal_handler(sig, frame):
interruptAllEvent.set()
return

# Fonction principale
def main() -> None:
# Créer un objet pour la communication série
ser = serial.Serial('/dev/ttyACM0', 460800)

# Créer un thread pour la communication série
thread = Thread(target=serial_thread, args=(ser,))

# Démarrer le thread de communication série
thread.start()

# Mettre en place le gestionnaire de signal pour les événements d'interruption (Ctrl+C)
signal.signal(signal.SIGINT, signal_handler)

# Attendre pendant 5 secondes et supprimer le fichier de données initial du capteur
sleep(5)
os.remove(os.path.dirname(__file__) + "/data/sensor_data_start")

while (1):
# Vérifier si l'événement d'interruption est défini
if interruptAllEvent.is_set():
# Attendre que le thread série se termine, puis sortir de la boucle
thread.join()
break

sleep(5)

# Ajuster les valeurs de minute et d'heure pour l'heure précédente
minute = datetime.datetime.now().minute - 1
hours = datetime.datetime.now().hour
if (minute < 0):
minute = minute + 60
hours = hours - 1

# On modifie tout les \n du fichier json afin que son transfert et sa réception vers le serveur
# soit du bon format. On protège donc tout les \n du fichier avant son envoie.
try:
# Lire et modifier le contenu du fichier de la minute précédente
with open(os.path.dirname(__file__) + "/data/sensor_data_" + datetime.datetime.now().strftime("%d_%m_%Y__") + str(hours) + "_" + str(minute) + "_00.json", "r+") as fichier:
line = fichier.read()
str(line).replace('\n','\\\n')
fichier.write(line)
except FileNotFoundError:
sleep(60)

# Créer une liste de chemins de fichiers pour les 10 dernières minutes
# Tout les autres sont amenés à être supprimés. Dans le but de préserver de la mémoire de stockage
file_to_keep = []
for i in range(0,10):
minute = datetime.datetime.now().minute - i
hours = datetime.datetime.now().hour
if (minute < 0):
minute = minute + 60
hours = hours - 1
path_string = os.path.dirname(__file__) + "/data/sensor_data_" + datetime.datetime.now().strftime("%d_%m_%Y__") + str(hours) + "_" + str(minute) + "_00.json"
file_to_keep.append(path_string)

# Obtenir une liste de tous les fichiers dans le répertoire data
files = glob.glob(os.path.dirname(__file__) + "/data/*")

# Créer une liste de fichiers à supprimer
files_to_remove = []

# Vérifier chaque fichier et l'ajouter à la liste de suppression s'il n'est pas dans la liste des fichiers à conserver
for file_name in files:
beRemoved = True
for f_keep in file_to_keep:
if file_name == f_keep:
beRemoved = False
break
if beRemoved:
files_to_remove.append(file_name)

# Supprimer les fichiers de la liste de suppression
for file_name in files_to_remove:
os.remove(file_name)

# Point d'entrée du script
if __name__ == '__main__':
main()

</syntaxhighlight>

=== Utilisation des programmes présentés ci-dessus ===
[[Fichier:20231220 173650.jpg|gauche|vignette|Aucun objet à reconnaitre]]
[[Fichier:20231220 173812.jpg|vignette|Un stabilo à reconnaitre]]
[[Fichier:20231220 173733.jpg|centre|vignette|Une colle à reconnaitre]]

SE5 ECEAI/eceai 2023/2024/Brenier-Nguyen

2024-01-20T14:11:18Z

Tbrenier : /* Résultats renvoyés par le programme de reconnaissance */

= Résumé de séance =
* Séance 1 :
** Création et configuration de la VM sur Chassiron
** Installation de NanoEdge
** Installation de STM32cube
** Installation de l'OS pour la Raspberry dans la carte micro SD
** Prise en main de Nanoedge, de nucléo et de STM32cube
** Début de réflexion sur l'application (métrologie)
*Séance 2:
**Mise en place du serveur python
**Mise en place du client python
**Test réussi de communication entre client et serveur via http
**Programmation de la carte nucléo pour transfert de valeur via liaison série
**Suite réflexion sur l'application (reconnaissance alphabet langue des signes, mouvement)
**Choix de l'application : reconnaissance d'objets appliqué aux fournitures scolaires
**Entraînement des modèles pour les différentes applications cités précédemment
**Finalement : entraînement à la reconnaissance d'objets de fournitures scolaires
*Séance 3:
**Entraînement d'un nouveau modèle.
**Écriture d'un programme permettant de récupérer les données du capteur et de les écrire dans un fichier.
*Séance 4 :
**Essai d'utilisation de la librairie créée grâce à Nanoedge.
**Amélioration du [[Code de récupération de donnée (sur la raspberry)|programme python]] permettant de récupérer les données du capteur.
***Création d'un fichier .txt afin de stocker les données du capteur toutes les minutes.
***Destruction automatique des fichiers de données ayant été crée il y a plus de 10 minutes.
**L’émulateur de la librairie ne fonctionne pas s'il est exécuté dans la raspberry... Nous l'exécutons désormais directement dans notre VM.
**Pour cela nous avons adapter notre programme python afin de récupérer les données à partir d'un json pour traiter ces données dans la VM.
***Création d'un fichier toutes les minutes (contenant au format json la date et les données au format csv)

=== <b>Code du serveur Python :</b> ===
<syntaxhighlight lang="python3">
from http.server import HTTPServer, BaseHTTPRequestHandler

import json

import socket

# Stocker les requ tes POST re ues

post_requests = []

class CustomHTTPHandler(BaseHTTPRequestHandler):

def do_GET(self):

if self.path == '/':

self.path = '/index.html'

if self.path == '/data':

self.send_response(200)

self.send_header('Content-type', 'application/json')

self.end_headers()

self.wfile.write(bytes(json.dumps(post_requests), 'utf-8'))

return

if self.path == '/index.html':

self.send_response(200)

self.send_header('Content-type', 'text/html')

self.end_headers()

# Cr er le contenu HTML avec les donn es POST

content = '<html><body><h1>Donn es POST:</h1><ul>'

for item in post_requests:

content += f'<li>{item}</li>'

content += '</ul></body></html>'

self.wfile.write(content.encode('utf-8'))

return

try:

file_to_open = open(self.path[1:]).read()

self.send_response(200)

self.send_header('Content-type', 'text/html')

self.end_headers()

self.wfile.write(bytes(file_to_open, 'utf-8'))

except FileNotFoundError:

self.send_error(404, 'File Not Found: %s' % self.path)

def do_POST(self):

content_length = int(self.headers['Content-Length'])

post_data = self.rfile.read(content_length).decode('utf-8')

# Ajouter les donn es POST la liste

post_requests.append(post_data)

# Envoyer une rponse HTTP

self.send_response(200)

self.end_headers()

self.wfile.write(b"POST request processed")

class HTTPServerV6(HTTPServer):

address_family = socket.AF_INET6

if __name__ == '__main__':

server_address = ('::', 8888) # ^icoute sur toutes les interfaces IPv6, p>

httpd = HTTPServerV6(server_address, CustomHTTPHandler)

print("Serveur actif sur le port", 8888)

httpd.serve_forever()
</syntaxhighlight>

=== '''Code du client Python :''' ===
<syntaxhighlight lang="python3">
import argparse
import requests
import json

def send_json_to_server(url, json_file):
# Charger les données CSV depuis le fichier spécifié
with open(json_file, 'r') as file:
data = json.load(file)

# En-têtes spécifiant que vous envoyez du CSV
headers = {'Content-Type': 'application/json'}

# Envoie de la requête HTTP POST avec les données
response = requests.post(url, data=json.dumps(data), headers=headers)

# Vérification de la réponse
if response.status_code == 200:
print('Requête envoyée avec succès!')
else:
print(f'Erreur {response.status_code}: {response.text}')

if __name__ == "__main__":
# Configurer les arguments en ligne de commande
parser = argparse.ArgumentParser(description='Client Python pour envoyer des JSON via HTTP.')
parser.add_argument('url', type=str, help='URL du serveur')
parser.add_argument('json_file', type=str, help='Chemin vers le fichier JSON à envoyer')

# Analyser les arguments
args = parser.parse_args()

# Appeler la fonction pour envoyer le JSON au serveur
send_json_to_server(args.url, args.json_file)
</syntaxhighlight>

=== '''Index permettant d'afficher le json de test que nous avons envoyé au serveur :''' ===
<syntaxhighlight lang="html">
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>Page d'Accueil</title>
</head>
<body>
<h1>Bienvenue sur Mon Serveur</h1>
<h2>Données POST reçues:</h2>
<ul id="data">

</ul>
</body>
</html>

</syntaxhighlight>

=== '''Capture montrant l'affichage d'un fichier json (sans aucun sens) envoyé au serveur depuis le client :''' ===

= Flash du capteur sur le logiciel STM32CubeIDE =
Le code ci-dessous est la fonction qui est appelé pour le traitement des capteurs. Nous avions décidé de définir le délimiteur de donnée avec un espace.
[[Fichier:CaptureIndexBrenierNguyen.png|centre|Démonstration du protocole HTTP]]

Ci-dessous, on retrouve de la ligne 8 à 12 la configuration du capteur que l'on a défini sur un quadrillage de 8 x 8.<syntaxhighlight lang="c" line="1">
static void MX_53L5A1_SimpleRanging_Process(void)
{
uint32_t Id;

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 */

/* 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);

if (status == BSP_ERROR_NONE)
{
//print_result(&Result);
print_result_IE(&Result);
}

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

HAL_Delay(POLLING_PERIOD);
}
}
</syntaxhighlight>Le code ci-dessous est la fonction qui nous permet d'afficher les données des capteurs via la liaison série.

On observe l'envoie des données avec un séparateur 'espace', puis lorsque les valeurs semblent incohérentes du point de vue du capteur, on envoie arbitrairement un -1 en sortie.

On obtient un jeu de donnée suivant le format : value espace value esapce .... value espace retour chariot (pour chaque lignes/quadrillage sur une ligne)<syntaxhighlight lang="c">
static void print_result_IE(RANGING_SENSOR_Result_t *Result)
{
int8_t j;
int8_t k;
int8_t l;
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("%ld ",(long)Result->ZoneResult[j+k].Distance[l]);
else
printf("%ld ", -1);
}
}
}
printf("\n");
}
</syntaxhighlight>

= Code de récupération de donnée (sur la raspberry) =
Nous avons le scénario suivant : le capteur qui envoie en continue les données de distance à la raspberry via la liaison série.

Nous avons donc écrit un script python afin de récupérer ces données, les formater dans un fichier format json dans le but de les envoyer sur la VM qui pourra traiter ces données avec l'émulateur obtenue via l'application NanoEdgeAI Studio.

Nous allons vous expliquez le script que nous avons réalisés :<syntaxhighlight lang="python3" line="1">
import serial
from threading import Thread, Event
from time import sleep
import os, sys, signal
import datetime
import glob

# Événement pour signaler l'arrêt des threads
interruptAllEvent = Event()

# Fonction de thread pour lire les données et les sauvegarder dans des fichiers
def serial_thread(ser: serial) -> None:
# Chemin du fichier pour les données initiales du capteur
# Ces données sont vouées à ne pas être utilisées
fileName_old = os.path.dirname(__file__) + "/data/sensor_data_start"

while (1):
if (interruptAllEvent.is_set()):
break

# Créer un nouveau fichier pour chaque minute avec l'horodatage actuel
fileName = os.path.dirname(__file__) + "/data/sensor_data_" + datetime.datetime.now().strftime("%d_%m_%Y__%H_%M_00") + ".json"

# Fermer le fichier de la minute précédente en ajoutant la parenthèse fermante
if (fileName_old != fileName):
with open(fileName_old, "a") as fichier:
fichier.write("\"}")

# Lire les données du port série
string = str(ser.readline(), encoding='utf-8')

# Ouvrir le fichier de la minute actuelle et écrire les données
with open(fileName, "a") as fichier:
# S'il s'agit d'une nouvelle minute, commencer un nouvel objet JSON
if (fileName_old != fileName):
fileName_old = fileName
fichier.write("{\"date\":\""+datetime.datetime.now().strftime("%d/%m/%Y-%H:%M:00")+"\",\"csv_file\":\"")

# Écrire les données dans le fichier
fichier.write(string)

# Gestionnaire de signal pour définir l'événement d'interruption lors d'une interruption clavier (Ctrl+C)
def signal_handler(sig, frame):
interruptAllEvent.set()
return

# Fonction principale
def main() -> None:
# Créer un objet pour la communication série
ser = serial.Serial('/dev/ttyACM0', 460800)

# Créer un thread pour la communication série
thread = Thread(target=serial_thread, args=(ser,))

# Démarrer le thread de communication série
thread.start()

# Mettre en place le gestionnaire de signal pour les événements d'interruption (Ctrl+C)
signal.signal(signal.SIGINT, signal_handler)

# Attendre pendant 5 secondes et supprimer le fichier de données initial du capteur
sleep(5)
os.remove(os.path.dirname(__file__) + "/data/sensor_data_start")

while (1):
# Vérifier si l'événement d'interruption est défini
if interruptAllEvent.is_set():
# Attendre que le thread série se termine, puis sortir de la boucle
thread.join()
break

sleep(5)

# Ajuster les valeurs de minute et d'heure pour l'heure précédente
minute = datetime.datetime.now().minute - 1
hours = datetime.datetime.now().hour
if (minute < 0):
minute = minute + 60
hours = hours - 1

# On modifie tout les \n du fichier json afin que son transfert et sa réception vers le serveur
# soit du bon format. On protège donc tout les \n du fichier avant son envoie.
try:
# Lire et modifier le contenu du fichier de la minute précédente
with open(os.path.dirname(__file__) + "/data/sensor_data_" + datetime.datetime.now().strftime("%d_%m_%Y__") + str(hours) + "_" + str(minute) + "_00.json", "r+") as fichier:
line = fichier.read()
str(line).replace('\n','\\\n')
fichier.write(line)
except FileNotFoundError:
sleep(60)

# Créer une liste de chemins de fichiers pour les 10 dernières minutes
# Tout les autres sont amenés à être supprimés. Dans le but de préserver de la mémoire de stockage
file_to_keep = []
for i in range(0,10):
minute = datetime.datetime.now().minute - i
hours = datetime.datetime.now().hour
if (minute < 0):
minute = minute + 60
hours = hours - 1
path_string = os.path.dirname(__file__) + "/data/sensor_data_" + datetime.datetime.now().strftime("%d_%m_%Y__") + str(hours) + "_" + str(minute) + "_00.json"
file_to_keep.append(path_string)

# Obtenir une liste de tous les fichiers dans le répertoire data
files = glob.glob(os.path.dirname(__file__) + "/data/*")

# Créer une liste de fichiers à supprimer
files_to_remove = []

# Vérifier chaque fichier et l'ajouter à la liste de suppression s'il n'est pas dans la liste des fichiers à conserver
for file_name in files:
beRemoved = True
for f_keep in file_to_keep:
if file_name == f_keep:
beRemoved = False
break
if beRemoved:
files_to_remove.append(file_name)

# Supprimer les fichiers de la liste de suppression
for file_name in files_to_remove:
os.remove(file_name)

# Point d'entrée du script
if __name__ == '__main__':
main()

</syntaxhighlight>

= Utilisation des programmes présentés ci-dessus =
[[Fichier:20231220 173650.jpg|gauche|vignette|Aucun objet à reconnaitre]]
[[Fichier:20231220 173812.jpg|vignette|Un stabilo à reconnaitre]]
[[Fichier:20231220 173733.jpg|centre|vignette|Une colle à reconnaitre]]

SE5 ECEAI/eceai 2023/2024/Brenier-Nguyen

2024-01-20T13:58:31Z

Tbrenier : /* Résultats renvoyés par le programme de reconnaissance */

* Séance 1 :
** Création et configuration de la VM sur Chassiron
** Installation de NanoEdge
** Installation de STM32cube
** Installation de l'OS pour la Raspberry dans la carte micro SD
** Prise en main de Nanoedge, de nucléo et de STM32cube
** Début de réflexion sur l'application (métrologie)
*Séance 2:
**Mise en place du serveur python
**Mise en place du client python
**Test réussi de communication entre client et serveur via http
**Programmation de la carte nucléo pour transfert de valeur via liaison série
**Suite réflexion sur l'application (reconnaissance alphabet langue des signes, mouvement)
**Choix de l'application : reconnaissance d'objets appliqué aux fournitures scolaires
**Entraînement des modèles pour les différentes applications cités précédemment
**Finalement : entraînement à la reconnaissance d'objets de fournitures scolaires
*Séance 3:
**Entraînement d'un nouveau modèle.
**Écriture d'un programme permettant de récupérer les données du capteur et de les écrire dans un fichier.
*Séance 4 :
**Essai d'utilisation de la librairie créée grâce à Nanoedge.
**Amélioration du programme python permettant de récupérer les données du capteur.
***Création d'un fichier .txt afin de stocker les données du capteur toutes les minutes.
***Destruction automatique des fichiers de données ayant été crée il y a plus de 10 minutes.
**L’émulateur de la librairie ne fonctionne pas s'il est exécuté dans la raspberry... Nous l'exécutons désormais directement dans notre VM.
**Pour cela nous avons adapter notre programme python afin de récupérer les données à partir d'un json pour traiter ces données dans la VM.
***Création d'un fichier toutes les minutes (contenant au format json la date et les données au format csv)

<b>Code du serveur Python :</b><syntaxhighlight lang="python3">
from http.server import HTTPServer, BaseHTTPRequestHandler

import json

import socket

# Stocker les requ tes POST re ues

post_requests = []

class CustomHTTPHandler(BaseHTTPRequestHandler):

def do_GET(self):

if self.path == '/':

self.path = '/index.html'

if self.path == '/data':

self.send_response(200)

self.send_header('Content-type', 'application/json')

self.end_headers()

self.wfile.write(bytes(json.dumps(post_requests), 'utf-8'))

return

if self.path == '/index.html':

self.send_response(200)

self.send_header('Content-type', 'text/html')

self.end_headers()

# Cr er le contenu HTML avec les donn es POST

content = '<html><body><h1>Donn es POST:</h1><ul>'

for item in post_requests:

content += f'<li>{item}</li>'

content += '</ul></body></html>'

self.wfile.write(content.encode('utf-8'))

return

try:

file_to_open = open(self.path[1:]).read()

self.send_response(200)

self.send_header('Content-type', 'text/html')

self.end_headers()

self.wfile.write(bytes(file_to_open, 'utf-8'))

except FileNotFoundError:

self.send_error(404, 'File Not Found: %s' % self.path)

def do_POST(self):

content_length = int(self.headers['Content-Length'])

post_data = self.rfile.read(content_length).decode('utf-8')

# Ajouter les donn es POST la liste

post_requests.append(post_data)

# Envoyer une rponse HTTP

self.send_response(200)

self.end_headers()

self.wfile.write(b"POST request processed")

class HTTPServerV6(HTTPServer):

address_family = socket.AF_INET6

if __name__ == '__main__':

server_address = ('::', 8888) # ^icoute sur toutes les interfaces IPv6, p>

httpd = HTTPServerV6(server_address, CustomHTTPHandler)

print("Serveur actif sur le port", 8888)

httpd.serve_forever()
</syntaxhighlight>'''Code du client Python :'''<syntaxhighlight lang="python3">
import argparse
import requests
import json

def send_json_to_server(url, json_file):
# Charger les données CSV depuis le fichier spécifié
with open(json_file, 'r') as file:
data = json.load(file)

# En-têtes spécifiant que vous envoyez du CSV
headers = {'Content-Type': 'application/json'}

# Envoie de la requête HTTP POST avec les données
response = requests.post(url, data=json.dumps(data), headers=headers)

# Vérification de la réponse
if response.status_code == 200:
print('Requête envoyée avec succès!')
else:
print(f'Erreur {response.status_code}: {response.text}')

if __name__ == "__main__":
# Configurer les arguments en ligne de commande
parser = argparse.ArgumentParser(description='Client Python pour envoyer des JSON via HTTP.')
parser.add_argument('url', type=str, help='URL du serveur')
parser.add_argument('json_file', type=str, help='Chemin vers le fichier JSON à envoyer')

# Analyser les arguments
args = parser.parse_args()

# Appeler la fonction pour envoyer le JSON au serveur
send_json_to_server(args.url, args.json_file)
</syntaxhighlight>'''Index permettant d'afficher le json de test que nous avons envoyé au serveur :'''<syntaxhighlight lang="html">
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>Page d'Accueil</title>
</head>
<body>
<h1>Bienvenue sur Mon Serveur</h1>
<h2>Données POST reçues:</h2>
<ul id="data">

</ul>
</body>
</html>

</syntaxhighlight>'''Capture montrant l'affichage d'un fichier json (sans aucun sens) envoyé au serveur depuis le client :'''

== Flash du capteur sur le logiciel STM32CubeIDE ==
Le code ci-dessous est la fonction qui est appelé pour le traitement des capteurs. Nous avions décidé de définir le délimiteur de donnée avec un espace.
[[Fichier:CaptureIndexBrenierNguyen.png|centre|Démonstration du protocole HTTP]]

Ci-dessous, on retrouve de la ligne 8 à 12 la configuration du capteur que l'on a défini sur un quadrillage de 8 x 8.<syntaxhighlight lang="c" line="1">
static void MX_53L5A1_SimpleRanging_Process(void)
{
uint32_t Id;

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 */

/* 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);

if (status == BSP_ERROR_NONE)
{
//print_result(&Result);
print_result_IE(&Result);
}

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

HAL_Delay(POLLING_PERIOD);
}
}
</syntaxhighlight>Le code ci-dessous est la fonction qui nous permet d'afficher les données des capteurs via la liaison série.

On observe l'envoie des données avec un séparateur 'espace', puis lorsque les valeurs semblent incohérentes du point de vue du capteur, on envoie arbitrairement un -1 en sortie.

On obtient un jeu de donnée suivant le format : value espace value esapce .... value espace retour chariot (pour chaque lignes/quadrillage sur une ligne)<syntaxhighlight lang="c">
static void print_result_IE(RANGING_SENSOR_Result_t *Result)
{
int8_t j;
int8_t k;
int8_t l;
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("%ld ",(long)Result->ZoneResult[j+k].Distance[l]);
else
printf("%ld ", -1);
}
}
}
printf("\n");
}
</syntaxhighlight>

== Code de récupération de donnée (sur la raspberry) ==
Nous avons le scénario suivant : le capteur qui envoie en continue les données de distance à la raspberry via la liaison série.

Nous avons donc écrit un script python afin de récupérer ces données, les formater dans un fichier format json dans le but de les envoyer sur la VM qui pourra traiter ces données avec l'émulateur obtenue via l'application NanoEdgeAI Studio.

Nous allons vous expliquez le script que nous avons réalisés :<syntaxhighlight lang="python3" line="1">
import serial
from threading import Thread, Event
from time import sleep
import os, sys, signal
import datetime
import glob

# Événement pour signaler l'arrêt des threads
interruptAllEvent = Event()

# Fonction de thread pour lire les données et les sauvegarder dans des fichiers
def serial_thread(ser: serial) -> None:
# Chemin du fichier pour les données initiales du capteur
# Ces données sont vouées à ne pas être utilisées
fileName_old = os.path.dirname(__file__) + "/data/sensor_data_start"

while (1):
if (interruptAllEvent.is_set()):
break

# Créer un nouveau fichier pour chaque minute avec l'horodatage actuel
fileName = os.path.dirname(__file__) + "/data/sensor_data_" + datetime.datetime.now().strftime("%d_%m_%Y__%H_%M_00") + ".json"

# Fermer le fichier de la minute précédente en ajoutant la parenthèse fermante
if (fileName_old != fileName):
with open(fileName_old, "a") as fichier:
fichier.write("\"}")

# Lire les données du port série
string = str(ser.readline(), encoding='utf-8')

# Ouvrir le fichier de la minute actuelle et écrire les données
with open(fileName, "a") as fichier:
# S'il s'agit d'une nouvelle minute, commencer un nouvel objet JSON
if (fileName_old != fileName):
fileName_old = fileName
fichier.write("{\"date\":\""+datetime.datetime.now().strftime("%d/%m/%Y-%H:%M:00")+"\",\"csv_file\":\"")

# Écrire les données dans le fichier
fichier.write(string)

# Gestionnaire de signal pour définir l'événement d'interruption lors d'une interruption clavier (Ctrl+C)
def signal_handler(sig, frame):
interruptAllEvent.set()
return

# Fonction principale
def main() -> None:
# Créer un objet pour la communication série
ser = serial.Serial('/dev/ttyACM0', 460800)

# Créer un thread pour la communication série
thread = Thread(target=serial_thread, args=(ser,))

# Démarrer le thread de communication série
thread.start()

# Mettre en place le gestionnaire de signal pour les événements d'interruption (Ctrl+C)
signal.signal(signal.SIGINT, signal_handler)

# Attendre pendant 5 secondes et supprimer le fichier de données initial du capteur
sleep(5)
os.remove(os.path.dirname(__file__) + "/data/sensor_data_start")

while (1):
# Vérifier si l'événement d'interruption est défini
if interruptAllEvent.is_set():
# Attendre que le thread série se termine, puis sortir de la boucle
thread.join()
break

sleep(5)

# Ajuster les valeurs de minute et d'heure pour l'heure précédente
minute = datetime.datetime.now().minute - 1
hours = datetime.datetime.now().hour
if (minute < 0):
minute = minute + 60
hours = hours - 1

# On modifie tout les \n du fichier json afin que son transfert et sa réception vers le serveur
# soit du bon format. On protège donc tout les \n du fichier avant son envoie.
try:
# Lire et modifier le contenu du fichier de la minute précédente
with open(os.path.dirname(__file__) + "/data/sensor_data_" + datetime.datetime.now().strftime("%d_%m_%Y__") + str(hours) + "_" + str(minute) + "_00.json", "r+") as fichier:
line = fichier.read()
str(line).replace('\n','\\\n')
fichier.write(line)
except FileNotFoundError:
sleep(60)

# Créer une liste de chemins de fichiers pour les 10 dernières minutes
# Tout les autres sont amenés à être supprimés. Dans le but de préserver de la mémoire de stockage
file_to_keep = []
for i in range(0,10):
minute = datetime.datetime.now().minute - i
hours = datetime.datetime.now().hour
if (minute < 0):
minute = minute + 60
hours = hours - 1
path_string = os.path.dirname(__file__) + "/data/sensor_data_" + datetime.datetime.now().strftime("%d_%m_%Y__") + str(hours) + "_" + str(minute) + "_00.json"
file_to_keep.append(path_string)

# Obtenir une liste de tous les fichiers dans le répertoire data
files = glob.glob(os.path.dirname(__file__) + "/data/*")

# Créer une liste de fichiers à supprimer
files_to_remove = []

# Vérifier chaque fichier et l'ajouter à la liste de suppression s'il n'est pas dans la liste des fichiers à conserver
for file_name in files:
beRemoved = True
for f_keep in file_to_keep:
if file_name == f_keep:
beRemoved = False
break
if beRemoved:
files_to_remove.append(file_name)

# Supprimer les fichiers de la liste de suppression
for file_name in files_to_remove:
os.remove(file_name)

# Point d'entrée du script
if __name__ == '__main__':
main()

</syntaxhighlight>

== Résultats renvoyés par le programme de reconnaissance ==
[[Fichier:20231220 173650.jpg|gauche|vignette|Aucun objet à reconnaitre]]
[[Fichier:20231220 173812.jpg|vignette|Un stabilo à reconnaitre]]
[[Fichier:20231220 173733.jpg|centre|vignette|Une colle à reconnaitre]]

Fichier:20231220 173812.jpg

2024-01-20T13:57:51Z

Tbrenier :

Un stabilo à reconnaitre

SE5 ECEAI/eceai 2023/2024/Brenier-Nguyen

2024-01-20T13:56:20Z

Tbrenier : /* Résultats renvoyés par le programme de reconnaissance */

SE5 ECEAI/eceai 2023/2024/Brenier-Nguyen

2024-01-20T13:56:03Z

Tbrenier : /* Résultats renvoyés par le programme de reconnaissance */

SE5 ECEAI/eceai 2023/2024/Brenier-Nguyen

2024-01-20T13:55:35Z

Tbrenier : /* Résultats renvoyés par le programme de reconnaissance */

* Séance 1 :
** Création et configuration de la VM sur Chassiron
** Installation de NanoEdge
** Installation de STM32cube
** Installation de l'OS pour la Raspberry dans la carte micro SD
** Prise en main de Nanoedge, de nucléo et de STM32cube
** Début de réflexion sur l'application (métrologie)
*Séance 2:
**Mise en place du serveur python
**Mise en place du client python
**Test réussi de communication entre client et serveur via http
**Programmation de la carte nucléo pour transfert de valeur via liaison série
**Suite réflexion sur l'application (reconnaissance alphabet langue des signes, mouvement)
**Choix de l'application : reconnaissance d'objets appliqué aux fournitures scolaires
**Entraînement des modèles pour les différentes applications cités précédemment
**Finalement : entraînement à la reconnaissance d'objets de fournitures scolaires
*Séance 3:
**Entraînement d'un nouveau modèle.
**Écriture d'un programme permettant de récupérer les données du capteur et de les écrire dans un fichier.
*Séance 4 :
**Essai d'utilisation de la librairie créée grâce à Nanoedge.
**Amélioration du programme python permettant de récupérer les données du capteur.
***Création d'un fichier .txt afin de stocker les données du capteur toutes les minutes.
***Destruction automatique des fichiers de données ayant été crée il y a plus de 10 minutes.
**L’émulateur de la librairie ne fonctionne pas s'il est exécuté dans la raspberry... Nous l'exécutons désormais directement dans notre VM.
**Pour cela nous avons adapter notre programme python afin de récupérer les données à partir d'un json pour traiter ces données dans la VM.
***Création d'un fichier toutes les minutes (contenant au format json la date et les données au format csv)

<b>Code du serveur Python :</b><syntaxhighlight lang="python3">
from http.server import HTTPServer, BaseHTTPRequestHandler

import json

import socket

# Stocker les requ tes POST re ues

post_requests = []

class CustomHTTPHandler(BaseHTTPRequestHandler):

def do_GET(self):

if self.path == '/':

self.path = '/index.html'

if self.path == '/data':

self.send_response(200)

self.send_header('Content-type', 'application/json')

self.end_headers()

self.wfile.write(bytes(json.dumps(post_requests), 'utf-8'))

return

if self.path == '/index.html':

self.send_response(200)

self.send_header('Content-type', 'text/html')

self.end_headers()

# Cr er le contenu HTML avec les donn es POST

content = '<html><body><h1>Donn es POST:</h1><ul>'

for item in post_requests:

content += f'<li>{item}</li>'

content += '</ul></body></html>'

self.wfile.write(content.encode('utf-8'))

return

try:

file_to_open = open(self.path[1:]).read()

self.send_response(200)

self.send_header('Content-type', 'text/html')

self.end_headers()

self.wfile.write(bytes(file_to_open, 'utf-8'))

except FileNotFoundError:

self.send_error(404, 'File Not Found: %s' % self.path)

def do_POST(self):

content_length = int(self.headers['Content-Length'])

post_data = self.rfile.read(content_length).decode('utf-8')

# Ajouter les donn es POST la liste

post_requests.append(post_data)

# Envoyer une rponse HTTP

self.send_response(200)

self.end_headers()

self.wfile.write(b"POST request processed")

class HTTPServerV6(HTTPServer):

address_family = socket.AF_INET6

if __name__ == '__main__':

server_address = ('::', 8888) # ^icoute sur toutes les interfaces IPv6, p>

httpd = HTTPServerV6(server_address, CustomHTTPHandler)

print("Serveur actif sur le port", 8888)

httpd.serve_forever()
</syntaxhighlight>'''Code du client Python :'''<syntaxhighlight lang="python3">
import argparse
import requests
import json

def send_json_to_server(url, json_file):
# Charger les données CSV depuis le fichier spécifié
with open(json_file, 'r') as file:
data = json.load(file)

# En-têtes spécifiant que vous envoyez du CSV
headers = {'Content-Type': 'application/json'}

# Envoie de la requête HTTP POST avec les données
response = requests.post(url, data=json.dumps(data), headers=headers)

# Vérification de la réponse
if response.status_code == 200:
print('Requête envoyée avec succès!')
else:
print(f'Erreur {response.status_code}: {response.text}')

if __name__ == "__main__":
# Configurer les arguments en ligne de commande
parser = argparse.ArgumentParser(description='Client Python pour envoyer des JSON via HTTP.')
parser.add_argument('url', type=str, help='URL du serveur')
parser.add_argument('json_file', type=str, help='Chemin vers le fichier JSON à envoyer')

# Analyser les arguments
args = parser.parse_args()

# Appeler la fonction pour envoyer le JSON au serveur
send_json_to_server(args.url, args.json_file)
</syntaxhighlight>'''Index permettant d'afficher le json de test que nous avons envoyé au serveur :'''<syntaxhighlight lang="html">
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>Page d'Accueil</title>
</head>
<body>
<h1>Bienvenue sur Mon Serveur</h1>
<h2>Données POST reçues:</h2>
<ul id="data">

</ul>
</body>
</html>

</syntaxhighlight>'''Capture montrant l'affichage d'un fichier json (sans aucun sens) envoyé au serveur depuis le client :'''

== Flash du capteur sur le logiciel STM32CubeIDE ==
Le code ci-dessous est la fonction qui est appelé pour le traitement des capteurs. Nous avions décidé de définir le délimiteur de donnée avec un espace.
[[Fichier:CaptureIndexBrenierNguyen.png|centre|Démonstration du protocole HTTP]]

Ci-dessous, on retrouve de la ligne 8 à 12 la configuration du capteur que l'on a défini sur un quadrillage de 8 x 8.<syntaxhighlight lang="c" line="1">
static void MX_53L5A1_SimpleRanging_Process(void)
{
uint32_t Id;

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 */

/* 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);

if (status == BSP_ERROR_NONE)
{
//print_result(&Result);
print_result_IE(&Result);
}

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

HAL_Delay(POLLING_PERIOD);
}
}
</syntaxhighlight>Le code ci-dessous est la fonction qui nous permet d'afficher les données des capteurs via la liaison série.

On observe l'envoie des données avec un séparateur 'espace', puis lorsque les valeurs semblent incohérentes du point de vue du capteur, on envoie arbitrairement un -1 en sortie.

On obtient un jeu de donnée suivant le format : value espace value esapce .... value espace retour chariot (pour chaque lignes/quadrillage sur une ligne)<syntaxhighlight lang="c">
static void print_result_IE(RANGING_SENSOR_Result_t *Result)
{
int8_t j;
int8_t k;
int8_t l;
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("%ld ",(long)Result->ZoneResult[j+k].Distance[l]);
else
printf("%ld ", -1);
}
}
}
printf("\n");
}
</syntaxhighlight>

== Code de récupération de donnée (sur la raspberry) ==
Nous avons le scénario suivant : le capteur qui envoie en continue les données de distance à la raspberry via la liaison série.

Nous avons donc écrit un script python afin de récupérer ces données, les formater dans un fichier format json dans le but de les envoyer sur la VM qui pourra traiter ces données avec l'émulateur obtenue via l'application NanoEdgeAI Studio.

Nous allons vous expliquez le script que nous avons réalisés :<syntaxhighlight lang="python3" line="1">
import serial
from threading import Thread, Event
from time import sleep
import os, sys, signal
import datetime
import glob

interruptAllEvent = Event()

def serial_thread(ser: serial) -> None:
fileName_old = os.path.dirname(__file__) + "/data/sensor_data_start"
while (1):
if (interruptAllEvent.is_set()):
break
fileName = os.path.dirname(__file__) + "/data/sensor_data_" + datetime.datetime.now().strftime("%d_%m_%Y__%H_%M_00") + ".json"

if (fileName_old != fileName):
with open(fileName_old, "a") as fichier:
fichier.write("\"}")

string = str(ser.readline(), encoding='utf-8')

with open(fileName, "a") as fichier:
if (fileName_old != fileName):
fileName_old = fileName
fichier.write("{\"date\":\""+datetime.datetime.now().strftime("%d/%m/%Y-%H:%M:00")+"\",\"csv_file\":\"")

fichier.write(string)

def signal_handler(sig, frame):
interruptAllEvent.set()
return

def main() -> None:
ser = serial.Serial('/dev/ttyACM0', 460800)
thread = Thread(target=serial_thread, args=(ser,))

thread.start()

signal.signal(signal.SIGINT, signal_handler)

sleep(5)
os.remove(os.path.dirname(__file__) + "/data/sensor_data_start")

while (1):
if interruptAllEvent.is_set():
thread.join()
break

sleep(5)

minute = datetime.datetime.now().minute - 1
hours = datetime.datetime.now().hour
if (minute < 0):
minute = minute + 60
hours = hours - 1
try:
with open(os.path.dirname(__file__) + "/data/sensor_data_" + datetime.datetime.now().strftime("%d_%m_%Y__") + str(hours) + "_" + str(minute) + "_00.json", "r+") as fichier:
line = fichier.read()
str(line).replace('\n','\\\n')
fichier.write(line)
except FileNotFoundError:
sleep(60)

file_to_keep = []
for i in range(0,10):
minute = datetime.datetime.now().minute - i
hours = datetime.datetime.now().hour
if (minute < 0):
minute = minute + 60
hours = hours - 1
path_string = os.path.dirname(__file__) + "/data/sensor_data_" + datetime.datetime.now().strftime("%d_%m_%Y__") + str(hours) + "_" + str(minute) + "_00.json"
file_to_keep.append(path_string)

files = glob.glob(os.path.dirname(__file__) + "/data/*")

files_to_remove = []

for file_name in files:
beRemoved = True
for f_keep in file_to_keep:
if file_name == f_keep:
beRemoved = False
break
if beRemoved:
files_to_remove.append(file_name)

for file_name in files_to_remove:
os.remove(file_name)

if __name__ == '__main__':
main()

</syntaxhighlight>

== Résultats renvoyés par le programme de reconnaissance ==
[[Fichier:20231220 173733.jpg|vignette|Une colle à reconnaitre]]
[[Fichier:20231220 173650.jpg|gauche|vignette|Aucun objet à reconnaitre]]

Fichier:20231220 173733.jpg

2024-01-20T13:55:03Z

Tbrenier :

Une colle à reconnaitre

SE5 ECEAI/eceai 2023/2024/Brenier-Nguyen

2024-01-20T13:53:10Z

Tbrenier : /* Résultats renvoyés par le programme de reconnaissance */

* Séance 1 :
** Création et configuration de la VM sur Chassiron
** Installation de NanoEdge
** Installation de STM32cube
** Installation de l'OS pour la Raspberry dans la carte micro SD
** Prise en main de Nanoedge, de nucléo et de STM32cube
** Début de réflexion sur l'application (métrologie)
*Séance 2:
**Mise en place du serveur python
**Mise en place du client python
**Test réussi de communication entre client et serveur via http
**Programmation de la carte nucléo pour transfert de valeur via liaison série
**Suite réflexion sur l'application (reconnaissance alphabet langue des signes, mouvement)
**Choix de l'application : reconnaissance d'objets appliqué aux fournitures scolaires
**Entraînement des modèles pour les différentes applications cités précédemment
**Finalement : entraînement à la reconnaissance d'objets de fournitures scolaires
*Séance 3:
**Entraînement d'un nouveau modèle.
**Écriture d'un programme permettant de récupérer les données du capteur et de les écrire dans un fichier.
*Séance 4 :
**Essai d'utilisation de la librairie créée grâce à Nanoedge.
**Amélioration du programme python permettant de récupérer les données du capteur.
***Création d'un fichier .txt afin de stocker les données du capteur toutes les minutes.
***Destruction automatique des fichiers de données ayant été crée il y a plus de 10 minutes.
**L’émulateur de la librairie ne fonctionne pas s'il est exécuté dans la raspberry... Nous l'exécutons désormais directement dans notre VM.
**Pour cela nous avons adapter notre programme python afin de récupérer les données à partir d'un json pour traiter ces données dans la VM.
***Création d'un fichier toutes les minutes (contenant au format json la date et les données au format csv)

<b>Code du serveur Python :</b><syntaxhighlight lang="python3">
from http.server import HTTPServer, BaseHTTPRequestHandler

import json

import socket

# Stocker les requ tes POST re ues

post_requests = []

class CustomHTTPHandler(BaseHTTPRequestHandler):

def do_GET(self):

if self.path == '/':

self.path = '/index.html'

if self.path == '/data':

self.send_response(200)

self.send_header('Content-type', 'application/json')

self.end_headers()

self.wfile.write(bytes(json.dumps(post_requests), 'utf-8'))

return

if self.path == '/index.html':

self.send_response(200)

self.send_header('Content-type', 'text/html')

self.end_headers()

# Cr er le contenu HTML avec les donn es POST

content = '<html><body><h1>Donn es POST:</h1><ul>'

for item in post_requests:

content += f'<li>{item}</li>'

content += '</ul></body></html>'

self.wfile.write(content.encode('utf-8'))

return

try:

file_to_open = open(self.path[1:]).read()

self.send_response(200)

self.send_header('Content-type', 'text/html')

self.end_headers()

self.wfile.write(bytes(file_to_open, 'utf-8'))

except FileNotFoundError:

self.send_error(404, 'File Not Found: %s' % self.path)

def do_POST(self):

content_length = int(self.headers['Content-Length'])

post_data = self.rfile.read(content_length).decode('utf-8')

# Ajouter les donn es POST la liste

post_requests.append(post_data)

# Envoyer une rponse HTTP

self.send_response(200)

self.end_headers()

self.wfile.write(b"POST request processed")

class HTTPServerV6(HTTPServer):

address_family = socket.AF_INET6

if __name__ == '__main__':

server_address = ('::', 8888) # ^icoute sur toutes les interfaces IPv6, p>

httpd = HTTPServerV6(server_address, CustomHTTPHandler)

print("Serveur actif sur le port", 8888)

httpd.serve_forever()
</syntaxhighlight>'''Code du client Python :'''<syntaxhighlight lang="python3">
import argparse
import requests
import json

def send_json_to_server(url, json_file):
# Charger les données CSV depuis le fichier spécifié
with open(json_file, 'r') as file:
data = json.load(file)

# En-têtes spécifiant que vous envoyez du CSV
headers = {'Content-Type': 'application/json'}

# Envoie de la requête HTTP POST avec les données
response = requests.post(url, data=json.dumps(data), headers=headers)

# Vérification de la réponse
if response.status_code == 200:
print('Requête envoyée avec succès!')
else:
print(f'Erreur {response.status_code}: {response.text}')

if __name__ == "__main__":
# Configurer les arguments en ligne de commande
parser = argparse.ArgumentParser(description='Client Python pour envoyer des JSON via HTTP.')
parser.add_argument('url', type=str, help='URL du serveur')
parser.add_argument('json_file', type=str, help='Chemin vers le fichier JSON à envoyer')

# Analyser les arguments
args = parser.parse_args()

# Appeler la fonction pour envoyer le JSON au serveur
send_json_to_server(args.url, args.json_file)
</syntaxhighlight>'''Index permettant d'afficher le json de test que nous avons envoyé au serveur :'''<syntaxhighlight lang="html">
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>Page d'Accueil</title>
</head>
<body>
<h1>Bienvenue sur Mon Serveur</h1>
<h2>Données POST reçues:</h2>
<ul id="data">

</ul>
</body>
</html>

</syntaxhighlight>'''Capture montrant l'affichage d'un fichier json (sans aucun sens) envoyé au serveur depuis le client :'''

== Flash du capteur sur le logiciel STM32CubeIDE ==
Le code ci-dessous est la fonction qui est appelé pour le traitement des capteurs. Nous avions décidé de définir le délimiteur de donnée avec un espace.
[[Fichier:CaptureIndexBrenierNguyen.png|centre|Démonstration du protocole HTTP]]

Ci-dessous, on retrouve de la ligne 8 à 12 la configuration du capteur que l'on a défini sur un quadrillage de 8 x 8.<syntaxhighlight lang="c" line="1">
static void MX_53L5A1_SimpleRanging_Process(void)
{
uint32_t Id;

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 */

/* 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);

if (status == BSP_ERROR_NONE)
{
//print_result(&Result);
print_result_IE(&Result);
}

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

HAL_Delay(POLLING_PERIOD);
}
}
</syntaxhighlight>Le code ci-dessous est la fonction qui nous permet d'afficher les données des capteurs via la liaison série.

On observe l'envoie des données avec un séparateur 'espace', puis lorsque les valeurs semblent incohérentes du point de vue du capteur, on envoie arbitrairement un -1 en sortie.

On obtient un jeu de donnée suivant le format : value espace value esapce .... value espace retour chariot (pour chaque lignes/quadrillage sur une ligne)<syntaxhighlight lang="c">
static void print_result_IE(RANGING_SENSOR_Result_t *Result)
{
int8_t j;
int8_t k;
int8_t l;
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("%ld ",(long)Result->ZoneResult[j+k].Distance[l]);
else
printf("%ld ", -1);
}
}
}
printf("\n");
}
</syntaxhighlight>

== Code de récupération de donnée (sur la raspberry) ==
Nous avons le scénario suivant : le capteur qui envoie en continue les données de distance à la raspberry via la liaison série.

Nous avons donc écrit un script python afin de récupérer ces données, les formater dans un fichier format json dans le but de les envoyer sur la VM qui pourra traiter ces données avec l'émulateur obtenue via l'application NanoEdgeAI Studio.

Nous allons vous expliquez le script que nous avons réalisés :<syntaxhighlight lang="python3" line="1">
import serial
from threading import Thread, Event
from time import sleep
import os, sys, signal
import datetime
import glob

interruptAllEvent = Event()

def serial_thread(ser: serial) -> None:
fileName_old = os.path.dirname(__file__) + "/data/sensor_data_start"
while (1):
if (interruptAllEvent.is_set()):
break
fileName = os.path.dirname(__file__) + "/data/sensor_data_" + datetime.datetime.now().strftime("%d_%m_%Y__%H_%M_00") + ".json"

if (fileName_old != fileName):
with open(fileName_old, "a") as fichier:
fichier.write("\"}")

string = str(ser.readline(), encoding='utf-8')

with open(fileName, "a") as fichier:
if (fileName_old != fileName):
fileName_old = fileName
fichier.write("{\"date\":\""+datetime.datetime.now().strftime("%d/%m/%Y-%H:%M:00")+"\",\"csv_file\":\"")

fichier.write(string)

def signal_handler(sig, frame):
interruptAllEvent.set()
return

def main() -> None:
ser = serial.Serial('/dev/ttyACM0', 460800)
thread = Thread(target=serial_thread, args=(ser,))

thread.start()

signal.signal(signal.SIGINT, signal_handler)

sleep(5)
os.remove(os.path.dirname(__file__) + "/data/sensor_data_start")

while (1):
if interruptAllEvent.is_set():
thread.join()
break

sleep(5)

minute = datetime.datetime.now().minute - 1
hours = datetime.datetime.now().hour
if (minute < 0):
minute = minute + 60
hours = hours - 1
try:
with open(os.path.dirname(__file__) + "/data/sensor_data_" + datetime.datetime.now().strftime("%d_%m_%Y__") + str(hours) + "_" + str(minute) + "_00.json", "r+") as fichier:
line = fichier.read()
str(line).replace('\n','\\\n')
fichier.write(line)
except FileNotFoundError:
sleep(60)

file_to_keep = []
for i in range(0,10):
minute = datetime.datetime.now().minute - i
hours = datetime.datetime.now().hour
if (minute < 0):
minute = minute + 60
hours = hours - 1
path_string = os.path.dirname(__file__) + "/data/sensor_data_" + datetime.datetime.now().strftime("%d_%m_%Y__") + str(hours) + "_" + str(minute) + "_00.json"
file_to_keep.append(path_string)

files = glob.glob(os.path.dirname(__file__) + "/data/*")

files_to_remove = []

for file_name in files:
beRemoved = True
for f_keep in file_to_keep:
if file_name == f_keep:
beRemoved = False
break
if beRemoved:
files_to_remove.append(file_name)

for file_name in files_to_remove:
os.remove(file_name)

if __name__ == '__main__':
main()

</syntaxhighlight>

== Résultats renvoyés par le programme de reconnaissance ==
[[Fichier:20231220 173650.jpg|gauche|vignette|Aucun objet à reconnaitre]]

SE5 ECEAI/eceai 2023/2024/Brenier-Nguyen

2024-01-20T13:52:05Z

Tbrenier : /* Résultats renvoyés par le programme de reconnaissance */

* Séance 1 :
** Création et configuration de la VM sur Chassiron
** Installation de NanoEdge
** Installation de STM32cube
** Installation de l'OS pour la Raspberry dans la carte micro SD
** Prise en main de Nanoedge, de nucléo et de STM32cube
** Début de réflexion sur l'application (métrologie)
*Séance 2:
**Mise en place du serveur python
**Mise en place du client python
**Test réussi de communication entre client et serveur via http
**Programmation de la carte nucléo pour transfert de valeur via liaison série
**Suite réflexion sur l'application (reconnaissance alphabet langue des signes, mouvement)
**Choix de l'application : reconnaissance d'objets appliqué aux fournitures scolaires
**Entraînement des modèles pour les différentes applications cités précédemment
**Finalement : entraînement à la reconnaissance d'objets de fournitures scolaires
*Séance 3:
**Entraînement d'un nouveau modèle.
**Écriture d'un programme permettant de récupérer les données du capteur et de les écrire dans un fichier.
*Séance 4 :
**Essai d'utilisation de la librairie créée grâce à Nanoedge.
**Amélioration du programme python permettant de récupérer les données du capteur.
***Création d'un fichier .txt afin de stocker les données du capteur toutes les minutes.
***Destruction automatique des fichiers de données ayant été crée il y a plus de 10 minutes.
**L’émulateur de la librairie ne fonctionne pas s'il est exécuté dans la raspberry... Nous l'exécutons désormais directement dans notre VM.
**Pour cela nous avons adapter notre programme python afin de récupérer les données à partir d'un json pour traiter ces données dans la VM.
***Création d'un fichier toutes les minutes (contenant au format json la date et les données au format csv)

<b>Code du serveur Python :</b><syntaxhighlight lang="python3">
from http.server import HTTPServer, BaseHTTPRequestHandler

import json

import socket

# Stocker les requ tes POST re ues

post_requests = []

class CustomHTTPHandler(BaseHTTPRequestHandler):

def do_GET(self):

if self.path == '/':

self.path = '/index.html'

if self.path == '/data':

self.send_response(200)

self.send_header('Content-type', 'application/json')

self.end_headers()

self.wfile.write(bytes(json.dumps(post_requests), 'utf-8'))

return

if self.path == '/index.html':

self.send_response(200)

self.send_header('Content-type', 'text/html')

self.end_headers()

# Cr er le contenu HTML avec les donn es POST

content = '<html><body><h1>Donn es POST:</h1><ul>'

for item in post_requests:

content += f'<li>{item}</li>'

content += '</ul></body></html>'

self.wfile.write(content.encode('utf-8'))

return

try:

file_to_open = open(self.path[1:]).read()

self.send_response(200)

self.send_header('Content-type', 'text/html')

self.end_headers()

self.wfile.write(bytes(file_to_open, 'utf-8'))

except FileNotFoundError:

self.send_error(404, 'File Not Found: %s' % self.path)

def do_POST(self):

content_length = int(self.headers['Content-Length'])

post_data = self.rfile.read(content_length).decode('utf-8')

# Ajouter les donn es POST la liste

post_requests.append(post_data)

# Envoyer une rponse HTTP

self.send_response(200)

self.end_headers()

self.wfile.write(b"POST request processed")

class HTTPServerV6(HTTPServer):

address_family = socket.AF_INET6

if __name__ == '__main__':

server_address = ('::', 8888) # ^icoute sur toutes les interfaces IPv6, p>

httpd = HTTPServerV6(server_address, CustomHTTPHandler)

print("Serveur actif sur le port", 8888)

httpd.serve_forever()
</syntaxhighlight>'''Code du client Python :'''<syntaxhighlight lang="python3">
import argparse
import requests
import json

def send_json_to_server(url, json_file):
# Charger les données CSV depuis le fichier spécifié
with open(json_file, 'r') as file:
data = json.load(file)

# En-têtes spécifiant que vous envoyez du CSV
headers = {'Content-Type': 'application/json'}

# Envoie de la requête HTTP POST avec les données
response = requests.post(url, data=json.dumps(data), headers=headers)

# Vérification de la réponse
if response.status_code == 200:
print('Requête envoyée avec succès!')
else:
print(f'Erreur {response.status_code}: {response.text}')

if __name__ == "__main__":
# Configurer les arguments en ligne de commande
parser = argparse.ArgumentParser(description='Client Python pour envoyer des JSON via HTTP.')
parser.add_argument('url', type=str, help='URL du serveur')
parser.add_argument('json_file', type=str, help='Chemin vers le fichier JSON à envoyer')

# Analyser les arguments
args = parser.parse_args()

# Appeler la fonction pour envoyer le JSON au serveur
send_json_to_server(args.url, args.json_file)
</syntaxhighlight>'''Index permettant d'afficher le json de test que nous avons envoyé au serveur :'''<syntaxhighlight lang="html">
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>Page d'Accueil</title>
</head>
<body>
<h1>Bienvenue sur Mon Serveur</h1>
<h2>Données POST reçues:</h2>
<ul id="data">

</ul>
</body>
</html>

</syntaxhighlight>'''Capture montrant l'affichage d'un fichier json (sans aucun sens) envoyé au serveur depuis le client :'''

== Flash du capteur sur le logiciel STM32CubeIDE ==
Le code ci-dessous est la fonction qui est appelé pour le traitement des capteurs. Nous avions décidé de définir le délimiteur de donnée avec un espace.
[[Fichier:CaptureIndexBrenierNguyen.png|centre|Démonstration du protocole HTTP]]

Ci-dessous, on retrouve de la ligne 8 à 12 la configuration du capteur que l'on a défini sur un quadrillage de 8 x 8.<syntaxhighlight lang="c" line="1">
static void MX_53L5A1_SimpleRanging_Process(void)
{
uint32_t Id;

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 */

/* 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);

if (status == BSP_ERROR_NONE)
{
//print_result(&Result);
print_result_IE(&Result);
}

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

HAL_Delay(POLLING_PERIOD);
}
}
</syntaxhighlight>Le code ci-dessous est la fonction qui nous permet d'afficher les données des capteurs via la liaison série.

On observe l'envoie des données avec un séparateur 'espace', puis lorsque les valeurs semblent incohérentes du point de vue du capteur, on envoie arbitrairement un -1 en sortie.

On obtient un jeu de donnée suivant le format : value espace value esapce .... value espace retour chariot (pour chaque lignes/quadrillage sur une ligne)<syntaxhighlight lang="c">
static void print_result_IE(RANGING_SENSOR_Result_t *Result)
{
int8_t j;
int8_t k;
int8_t l;
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("%ld ",(long)Result->ZoneResult[j+k].Distance[l]);
else
printf("%ld ", -1);
}
}
}
printf("\n");
}
</syntaxhighlight>

== Code de récupération de donnée (sur la raspberry) ==
Nous avons le scénario suivant : le capteur qui envoie en continue les données de distance à la raspberry via la liaison série.

Nous avons donc écrit un script python afin de récupérer ces données, les formater dans un fichier format json dans le but de les envoyer sur la VM qui pourra traiter ces données avec l'émulateur obtenue via l'application NanoEdgeAI Studio.

Nous allons vous expliquez le script que nous avons réalisés :<syntaxhighlight lang="python3" line="1">
import serial
from threading import Thread, Event
from time import sleep
import os, sys, signal
import datetime
import glob

interruptAllEvent = Event()

def serial_thread(ser: serial) -> None:
fileName_old = os.path.dirname(__file__) + "/data/sensor_data_start"
while (1):
if (interruptAllEvent.is_set()):
break
fileName = os.path.dirname(__file__) + "/data/sensor_data_" + datetime.datetime.now().strftime("%d_%m_%Y__%H_%M_00") + ".json"

if (fileName_old != fileName):
with open(fileName_old, "a") as fichier:
fichier.write("\"}")

string = str(ser.readline(), encoding='utf-8')

with open(fileName, "a") as fichier:
if (fileName_old != fileName):
fileName_old = fileName
fichier.write("{\"date\":\""+datetime.datetime.now().strftime("%d/%m/%Y-%H:%M:00")+"\",\"csv_file\":\"")

fichier.write(string)

def signal_handler(sig, frame):
interruptAllEvent.set()
return

def main() -> None:
ser = serial.Serial('/dev/ttyACM0', 460800)
thread = Thread(target=serial_thread, args=(ser,))

thread.start()

signal.signal(signal.SIGINT, signal_handler)

sleep(5)
os.remove(os.path.dirname(__file__) + "/data/sensor_data_start")

while (1):
if interruptAllEvent.is_set():
thread.join()
break

sleep(5)

minute = datetime.datetime.now().minute - 1
hours = datetime.datetime.now().hour
if (minute < 0):
minute = minute + 60
hours = hours - 1
try:
with open(os.path.dirname(__file__) + "/data/sensor_data_" + datetime.datetime.now().strftime("%d_%m_%Y__") + str(hours) + "_" + str(minute) + "_00.json", "r+") as fichier:
line = fichier.read()
str(line).replace('\n','\\\n')
fichier.write(line)
except FileNotFoundError:
sleep(60)

file_to_keep = []
for i in range(0,10):
minute = datetime.datetime.now().minute - i
hours = datetime.datetime.now().hour
if (minute < 0):
minute = minute + 60
hours = hours - 1
path_string = os.path.dirname(__file__) + "/data/sensor_data_" + datetime.datetime.now().strftime("%d_%m_%Y__") + str(hours) + "_" + str(minute) + "_00.json"
file_to_keep.append(path_string)

files = glob.glob(os.path.dirname(__file__) + "/data/*")

files_to_remove = []

for file_name in files:
beRemoved = True
for f_keep in file_to_keep:
if file_name == f_keep:
beRemoved = False
break
if beRemoved:
files_to_remove.append(file_name)

for file_name in files_to_remove:
os.remove(file_name)

if __name__ == '__main__':
main()

</syntaxhighlight>

== Résultats renvoyés par le programme de reconnaissance ==
[[Fichier:20231220 173650.jpg|centre|Aucun objet à reconnaitre]]

SE5 ECEAI/eceai 2023/2024/Brenier-Nguyen

2024-01-20T13:51:23Z

Tbrenier : /* Résultats renvoyés par le programme de reconnaissance */

* Séance 1 :
** Création et configuration de la VM sur Chassiron
** Installation de NanoEdge
** Installation de STM32cube
** Installation de l'OS pour la Raspberry dans la carte micro SD
** Prise en main de Nanoedge, de nucléo et de STM32cube
** Début de réflexion sur l'application (métrologie)
*Séance 2:
**Mise en place du serveur python
**Mise en place du client python
**Test réussi de communication entre client et serveur via http
**Programmation de la carte nucléo pour transfert de valeur via liaison série
**Suite réflexion sur l'application (reconnaissance alphabet langue des signes, mouvement)
**Choix de l'application : reconnaissance d'objets appliqué aux fournitures scolaires
**Entraînement des modèles pour les différentes applications cités précédemment
**Finalement : entraînement à la reconnaissance d'objets de fournitures scolaires
*Séance 3:
**Entraînement d'un nouveau modèle.
**Écriture d'un programme permettant de récupérer les données du capteur et de les écrire dans un fichier.
*Séance 4 :
**Essai d'utilisation de la librairie créée grâce à Nanoedge.
**Amélioration du programme python permettant de récupérer les données du capteur.
***Création d'un fichier .txt afin de stocker les données du capteur toutes les minutes.
***Destruction automatique des fichiers de données ayant été crée il y a plus de 10 minutes.
**L’émulateur de la librairie ne fonctionne pas s'il est exécuté dans la raspberry... Nous l'exécutons désormais directement dans notre VM.
**Pour cela nous avons adapter notre programme python afin de récupérer les données à partir d'un json pour traiter ces données dans la VM.
***Création d'un fichier toutes les minutes (contenant au format json la date et les données au format csv)

<b>Code du serveur Python :</b><syntaxhighlight lang="python3">
from http.server import HTTPServer, BaseHTTPRequestHandler

import json

import socket

# Stocker les requ tes POST re ues

post_requests = []

class CustomHTTPHandler(BaseHTTPRequestHandler):

def do_GET(self):

if self.path == '/':

self.path = '/index.html'

if self.path == '/data':

self.send_response(200)

self.send_header('Content-type', 'application/json')

self.end_headers()

self.wfile.write(bytes(json.dumps(post_requests), 'utf-8'))

return

if self.path == '/index.html':

self.send_response(200)

self.send_header('Content-type', 'text/html')

self.end_headers()

# Cr er le contenu HTML avec les donn es POST

content = '<html><body><h1>Donn es POST:</h1><ul>'

for item in post_requests:

content += f'<li>{item}</li>'

content += '</ul></body></html>'

self.wfile.write(content.encode('utf-8'))

return

try:

file_to_open = open(self.path[1:]).read()

self.send_response(200)

self.send_header('Content-type', 'text/html')

self.end_headers()

self.wfile.write(bytes(file_to_open, 'utf-8'))

except FileNotFoundError:

self.send_error(404, 'File Not Found: %s' % self.path)

def do_POST(self):

content_length = int(self.headers['Content-Length'])

post_data = self.rfile.read(content_length).decode('utf-8')

# Ajouter les donn es POST la liste

post_requests.append(post_data)

# Envoyer une rponse HTTP

self.send_response(200)

self.end_headers()

self.wfile.write(b"POST request processed")

class HTTPServerV6(HTTPServer):

address_family = socket.AF_INET6

if __name__ == '__main__':

server_address = ('::', 8888) # ^icoute sur toutes les interfaces IPv6, p>

httpd = HTTPServerV6(server_address, CustomHTTPHandler)

print("Serveur actif sur le port", 8888)

httpd.serve_forever()
</syntaxhighlight>'''Code du client Python :'''<syntaxhighlight lang="python3">
import argparse
import requests
import json

def send_json_to_server(url, json_file):
# Charger les données CSV depuis le fichier spécifié
with open(json_file, 'r') as file:
data = json.load(file)

# En-têtes spécifiant que vous envoyez du CSV
headers = {'Content-Type': 'application/json'}

# Envoie de la requête HTTP POST avec les données
response = requests.post(url, data=json.dumps(data), headers=headers)

# Vérification de la réponse
if response.status_code == 200:
print('Requête envoyée avec succès!')
else:
print(f'Erreur {response.status_code}: {response.text}')

if __name__ == "__main__":
# Configurer les arguments en ligne de commande
parser = argparse.ArgumentParser(description='Client Python pour envoyer des JSON via HTTP.')
parser.add_argument('url', type=str, help='URL du serveur')
parser.add_argument('json_file', type=str, help='Chemin vers le fichier JSON à envoyer')

# Analyser les arguments
args = parser.parse_args()

# Appeler la fonction pour envoyer le JSON au serveur
send_json_to_server(args.url, args.json_file)
</syntaxhighlight>'''Index permettant d'afficher le json de test que nous avons envoyé au serveur :'''<syntaxhighlight lang="html">
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>Page d'Accueil</title>
</head>
<body>
<h1>Bienvenue sur Mon Serveur</h1>
<h2>Données POST reçues:</h2>
<ul id="data">

</ul>
</body>
</html>

</syntaxhighlight>'''Capture montrant l'affichage d'un fichier json (sans aucun sens) envoyé au serveur depuis le client :'''

== Flash du capteur sur le logiciel STM32CubeIDE ==
Le code ci-dessous est la fonction qui est appelé pour le traitement des capteurs. Nous avions décidé de définir le délimiteur de donnée avec un espace.
[[Fichier:CaptureIndexBrenierNguyen.png|centre|Démonstration du protocole HTTP]]

Ci-dessous, on retrouve de la ligne 8 à 12 la configuration du capteur que l'on a défini sur un quadrillage de 8 x 8.<syntaxhighlight lang="c" line="1">
static void MX_53L5A1_SimpleRanging_Process(void)
{
uint32_t Id;

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 */

/* 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);

if (status == BSP_ERROR_NONE)
{
//print_result(&Result);
print_result_IE(&Result);
}

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

HAL_Delay(POLLING_PERIOD);
}
}
</syntaxhighlight>Le code ci-dessous est la fonction qui nous permet d'afficher les données des capteurs via la liaison série.

On observe l'envoie des données avec un séparateur 'espace', puis lorsque les valeurs semblent incohérentes du point de vue du capteur, on envoie arbitrairement un -1 en sortie.

On obtient un jeu de donnée suivant le format : value espace value esapce .... value espace retour chariot (pour chaque lignes/quadrillage sur une ligne)<syntaxhighlight lang="c">
static void print_result_IE(RANGING_SENSOR_Result_t *Result)
{
int8_t j;
int8_t k;
int8_t l;
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("%ld ",(long)Result->ZoneResult[j+k].Distance[l]);
else
printf("%ld ", -1);
}
}
}
printf("\n");
}
</syntaxhighlight>

== Code de récupération de donnée (sur la raspberry) ==
Nous avons le scénario suivant : le capteur qui envoie en continue les données de distance à la raspberry via la liaison série.

Nous avons donc écrit un script python afin de récupérer ces données, les formater dans un fichier format json dans le but de les envoyer sur la VM qui pourra traiter ces données avec l'émulateur obtenue via l'application NanoEdgeAI Studio.

Nous allons vous expliquez le script que nous avons réalisés :<syntaxhighlight lang="python3" line="1">
import serial
from threading import Thread, Event
from time import sleep
import os, sys, signal
import datetime
import glob

interruptAllEvent = Event()

def serial_thread(ser: serial) -> None:
fileName_old = os.path.dirname(__file__) + "/data/sensor_data_start"
while (1):
if (interruptAllEvent.is_set()):
break
fileName = os.path.dirname(__file__) + "/data/sensor_data_" + datetime.datetime.now().strftime("%d_%m_%Y__%H_%M_00") + ".json"

if (fileName_old != fileName):
with open(fileName_old, "a") as fichier:
fichier.write("\"}")

string = str(ser.readline(), encoding='utf-8')

with open(fileName, "a") as fichier:
if (fileName_old != fileName):
fileName_old = fileName
fichier.write("{\"date\":\""+datetime.datetime.now().strftime("%d/%m/%Y-%H:%M:00")+"\",\"csv_file\":\"")

fichier.write(string)

def signal_handler(sig, frame):
interruptAllEvent.set()
return

def main() -> None:
ser = serial.Serial('/dev/ttyACM0', 460800)
thread = Thread(target=serial_thread, args=(ser,))

thread.start()

signal.signal(signal.SIGINT, signal_handler)

sleep(5)
os.remove(os.path.dirname(__file__) + "/data/sensor_data_start")

while (1):
if interruptAllEvent.is_set():
thread.join()
break

sleep(5)

minute = datetime.datetime.now().minute - 1
hours = datetime.datetime.now().hour
if (minute < 0):
minute = minute + 60
hours = hours - 1
try:
with open(os.path.dirname(__file__) + "/data/sensor_data_" + datetime.datetime.now().strftime("%d_%m_%Y__") + str(hours) + "_" + str(minute) + "_00.json", "r+") as fichier:
line = fichier.read()
str(line).replace('\n','\\\n')
fichier.write(line)
except FileNotFoundError:
sleep(60)

file_to_keep = []
for i in range(0,10):
minute = datetime.datetime.now().minute - i
hours = datetime.datetime.now().hour
if (minute < 0):
minute = minute + 60
hours = hours - 1
path_string = os.path.dirname(__file__) + "/data/sensor_data_" + datetime.datetime.now().strftime("%d_%m_%Y__") + str(hours) + "_" + str(minute) + "_00.json"
file_to_keep.append(path_string)

files = glob.glob(os.path.dirname(__file__) + "/data/*")

files_to_remove = []

for file_name in files:
beRemoved = True
for f_keep in file_to_keep:
if file_name == f_keep:
beRemoved = False
break
if beRemoved:
files_to_remove.append(file_name)

for file_name in files_to_remove:
os.remove(file_name)

if __name__ == '__main__':
main()

</syntaxhighlight>

== Résultats renvoyés par le programme de reconnaissance ==
[[Fichier:20231220 173650.jpg|vignette|Aucun objet à reconnaitre]]

Fichier:20231220 173650.jpg

2024-01-20T13:50:43Z

Tbrenier :

Aucun objet à reconnaitre

SE5 ECEAI/eceai 2023/2024/Brenier-Nguyen

2024-01-20T13:43:59Z

Tbrenier : /* Code de récupération de donnée (sur la raspberry) */

* Séance 1 :
** Création et configuration de la VM sur Chassiron
** Installation de NanoEdge
** Installation de STM32cube
** Installation de l'OS pour la Raspberry dans la carte micro SD
** Prise en main de Nanoedge, de nucléo et de STM32cube
** Début de réflexion sur l'application (métrologie)
*Séance 2:
**Mise en place du serveur python
**Mise en place du client python
**Test réussi de communication entre client et serveur via http
**Programmation de la carte nucléo pour transfert de valeur via liaison série
**Suite réflexion sur l'application (reconnaissance alphabet langue des signes, mouvement)
**Choix de l'application : reconnaissance d'objets appliqué aux fournitures scolaires
**Entraînement des modèles pour les différentes applications cités précédemment
**Finalement : entraînement à la reconnaissance d'objets de fournitures scolaires
*Séance 3:
**Entraînement d'un nouveau modèle.
**Écriture d'un programme permettant de récupérer les données du capteur et de les écrire dans un fichier.
*Séance 4 :
**Essai d'utilisation de la librairie créée grâce à Nanoedge.
**Amélioration du programme python permettant de récupérer les données du capteur.
***Création d'un fichier .txt afin de stocker les données du capteur toutes les minutes.
***Destruction automatique des fichiers de données ayant été crée il y a plus de 10 minutes.
**L’émulateur de la librairie ne fonctionne pas s'il est exécuté dans la raspberry... Nous l'exécutons désormais directement dans notre VM.
**Pour cela nous avons adapter notre programme python afin de récupérer les données à partir d'un json pour traiter ces données dans la VM.
***Création d'un fichier toutes les minutes (contenant au format json la date et les données au format csv)

<b>Code du serveur Python :</b><syntaxhighlight lang="python3">
from http.server import HTTPServer, BaseHTTPRequestHandler

import json

import socket

# Stocker les requ tes POST re ues

post_requests = []

class CustomHTTPHandler(BaseHTTPRequestHandler):

def do_GET(self):

if self.path == '/':

self.path = '/index.html'

if self.path == '/data':

self.send_response(200)

self.send_header('Content-type', 'application/json')

self.end_headers()

self.wfile.write(bytes(json.dumps(post_requests), 'utf-8'))

return

if self.path == '/index.html':

self.send_response(200)

self.send_header('Content-type', 'text/html')

self.end_headers()

# Cr er le contenu HTML avec les donn es POST

content = '<html><body><h1>Donn es POST:</h1><ul>'

for item in post_requests:

content += f'<li>{item}</li>'

content += '</ul></body></html>'

self.wfile.write(content.encode('utf-8'))

return

try:

file_to_open = open(self.path[1:]).read()

self.send_response(200)

self.send_header('Content-type', 'text/html')

self.end_headers()

self.wfile.write(bytes(file_to_open, 'utf-8'))

except FileNotFoundError:

self.send_error(404, 'File Not Found: %s' % self.path)

def do_POST(self):

content_length = int(self.headers['Content-Length'])

post_data = self.rfile.read(content_length).decode('utf-8')

# Ajouter les donn es POST la liste

post_requests.append(post_data)

# Envoyer une rponse HTTP

self.send_response(200)

self.end_headers()

self.wfile.write(b"POST request processed")

class HTTPServerV6(HTTPServer):

address_family = socket.AF_INET6

if __name__ == '__main__':

server_address = ('::', 8888) # ^icoute sur toutes les interfaces IPv6, p>

httpd = HTTPServerV6(server_address, CustomHTTPHandler)

print("Serveur actif sur le port", 8888)

httpd.serve_forever()
</syntaxhighlight>'''Code du client Python :'''<syntaxhighlight lang="python3">
import argparse
import requests
import json

def send_json_to_server(url, json_file):
# Charger les données CSV depuis le fichier spécifié
with open(json_file, 'r') as file:
data = json.load(file)

# En-têtes spécifiant que vous envoyez du CSV
headers = {'Content-Type': 'application/json'}

# Envoie de la requête HTTP POST avec les données
response = requests.post(url, data=json.dumps(data), headers=headers)

# Vérification de la réponse
if response.status_code == 200:
print('Requête envoyée avec succès!')
else:
print(f'Erreur {response.status_code}: {response.text}')

if __name__ == "__main__":
# Configurer les arguments en ligne de commande
parser = argparse.ArgumentParser(description='Client Python pour envoyer des JSON via HTTP.')
parser.add_argument('url', type=str, help='URL du serveur')
parser.add_argument('json_file', type=str, help='Chemin vers le fichier JSON à envoyer')

# Analyser les arguments
args = parser.parse_args()

# Appeler la fonction pour envoyer le JSON au serveur
send_json_to_server(args.url, args.json_file)
</syntaxhighlight>'''Index permettant d'afficher le json de test que nous avons envoyé au serveur :'''<syntaxhighlight lang="html">
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>Page d'Accueil</title>
</head>
<body>
<h1>Bienvenue sur Mon Serveur</h1>
<h2>Données POST reçues:</h2>
<ul id="data">

</ul>
</body>
</html>

</syntaxhighlight>'''Capture montrant l'affichage d'un fichier json (sans aucun sens) envoyé au serveur depuis le client :'''

== Flash du capteur sur le logiciel STM32CubeIDE ==
Le code ci-dessous est la fonction qui est appelé pour le traitement des capteurs. Nous avions décidé de définir le délimiteur de donnée avec un espace.
[[Fichier:CaptureIndexBrenierNguyen.png|centre|Démonstration du protocole HTTP]]

Ci-dessous, on retrouve de la ligne 8 à 12 la configuration du capteur que l'on a défini sur un quadrillage de 8 x 8.<syntaxhighlight lang="c" line="1">
static void MX_53L5A1_SimpleRanging_Process(void)
{
uint32_t Id;

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 */

/* 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);

if (status == BSP_ERROR_NONE)
{
//print_result(&Result);
print_result_IE(&Result);
}

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

HAL_Delay(POLLING_PERIOD);
}
}
</syntaxhighlight>Le code ci-dessous est la fonction qui nous permet d'afficher les données des capteurs via la liaison série.

On observe l'envoie des données avec un séparateur 'espace', puis lorsque les valeurs semblent incohérentes du point de vue du capteur, on envoie arbitrairement un -1 en sortie.

On obtient un jeu de donnée suivant le format : value espace value esapce .... value espace retour chariot (pour chaque lignes/quadrillage sur une ligne)<syntaxhighlight lang="c">
static void print_result_IE(RANGING_SENSOR_Result_t *Result)
{
int8_t j;
int8_t k;
int8_t l;
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("%ld ",(long)Result->ZoneResult[j+k].Distance[l]);
else
printf("%ld ", -1);
}
}
}
printf("\n");
}
</syntaxhighlight>

== Code de récupération de donnée (sur la raspberry) ==
Nous avons le scénario suivant : le capteur qui envoie en continue les données de distance à la raspberry via la liaison série.

Nous avons donc écrit un script python afin de récupérer ces données, les formater dans un fichier format json dans le but de les envoyer sur la VM qui pourra traiter ces données avec l'émulateur obtenue via l'application NanoEdgeAI Studio.

Nous allons vous expliquez le script que nous avons réalisés :<syntaxhighlight lang="python3" line="1">
import serial
from threading import Thread, Event
from time import sleep
import os, sys, signal
import datetime
import glob

interruptAllEvent = Event()

def serial_thread(ser: serial) -> None:
fileName_old = os.path.dirname(__file__) + "/data/sensor_data_start"
while (1):
if (interruptAllEvent.is_set()):
break
fileName = os.path.dirname(__file__) + "/data/sensor_data_" + datetime.datetime.now().strftime("%d_%m_%Y__%H_%M_00") + ".json"

if (fileName_old != fileName):
with open(fileName_old, "a") as fichier:
fichier.write("\"}")

string = str(ser.readline(), encoding='utf-8')

with open(fileName, "a") as fichier:
if (fileName_old != fileName):
fileName_old = fileName
fichier.write("{\"date\":\""+datetime.datetime.now().strftime("%d/%m/%Y-%H:%M:00")+"\",\"csv_file\":\"")

fichier.write(string)

def signal_handler(sig, frame):
interruptAllEvent.set()
return

def main() -> None:
ser = serial.Serial('/dev/ttyACM0', 460800)
thread = Thread(target=serial_thread, args=(ser,))

thread.start()

signal.signal(signal.SIGINT, signal_handler)

sleep(5)
os.remove(os.path.dirname(__file__) + "/data/sensor_data_start")

while (1):
if interruptAllEvent.is_set():
thread.join()
break

sleep(5)

minute = datetime.datetime.now().minute - 1
hours = datetime.datetime.now().hour
if (minute < 0):
minute = minute + 60
hours = hours - 1
try:
with open(os.path.dirname(__file__) + "/data/sensor_data_" + datetime.datetime.now().strftime("%d_%m_%Y__") + str(hours) + "_" + str(minute) + "_00.json", "r+") as fichier:
line = fichier.read()
str(line).replace('\n','\\\n')
fichier.write(line)
except FileNotFoundError:
sleep(60)

file_to_keep = []
for i in range(0,10):
minute = datetime.datetime.now().minute - i
hours = datetime.datetime.now().hour
if (minute < 0):
minute = minute + 60
hours = hours - 1
path_string = os.path.dirname(__file__) + "/data/sensor_data_" + datetime.datetime.now().strftime("%d_%m_%Y__") + str(hours) + "_" + str(minute) + "_00.json"
file_to_keep.append(path_string)

files = glob.glob(os.path.dirname(__file__) + "/data/*")

files_to_remove = []

for file_name in files:
beRemoved = True
for f_keep in file_to_keep:
if file_name == f_keep:
beRemoved = False
break
if beRemoved:
files_to_remove.append(file_name)

for file_name in files_to_remove:
os.remove(file_name)

if __name__ == '__main__':
main()

</syntaxhighlight>

== Résultats renvoyés par le programme de reconnaissance ==

SE5 ECEAI/eceai 2023/2024/Brenier-Nguyen

2024-01-20T13:41:56Z

Tbrenier : /* Flash du capteur sur le logiciel STM32CubeIDE */

* Séance 1 :
** Création et configuration de la VM sur Chassiron
** Installation de NanoEdge
** Installation de STM32cube
** Installation de l'OS pour la Raspberry dans la carte micro SD
** Prise en main de Nanoedge, de nucléo et de STM32cube
** Début de réflexion sur l'application (métrologie)
*Séance 2:
**Mise en place du serveur python
**Mise en place du client python
**Test réussi de communication entre client et serveur via http
**Programmation de la carte nucléo pour transfert de valeur via liaison série
**Suite réflexion sur l'application (reconnaissance alphabet langue des signes, mouvement)
**Choix de l'application : reconnaissance d'objets appliqué aux fournitures scolaires
**Entraînement des modèles pour les différentes applications cités précédemment
**Finalement : entraînement à la reconnaissance d'objets de fournitures scolaires
*Séance 3:
**Entraînement d'un nouveau modèle.
**Écriture d'un programme permettant de récupérer les données du capteur et de les écrire dans un fichier.
*Séance 4 :
**Essai d'utilisation de la librairie créée grâce à Nanoedge.
**Amélioration du programme python permettant de récupérer les données du capteur.
***Création d'un fichier .txt afin de stocker les données du capteur toutes les minutes.
***Destruction automatique des fichiers de données ayant été crée il y a plus de 10 minutes.
**L’émulateur de la librairie ne fonctionne pas s'il est exécuté dans la raspberry... Nous l'exécutons désormais directement dans notre VM.
**Pour cela nous avons adapter notre programme python afin de récupérer les données à partir d'un json pour traiter ces données dans la VM.
***Création d'un fichier toutes les minutes (contenant au format json la date et les données au format csv)

<b>Code du serveur Python :</b><syntaxhighlight lang="python3">
from http.server import HTTPServer, BaseHTTPRequestHandler

import json

import socket

# Stocker les requ tes POST re ues

post_requests = []

class CustomHTTPHandler(BaseHTTPRequestHandler):

def do_GET(self):

if self.path == '/':

self.path = '/index.html'

if self.path == '/data':

self.send_response(200)

self.send_header('Content-type', 'application/json')

self.end_headers()

self.wfile.write(bytes(json.dumps(post_requests), 'utf-8'))

return

if self.path == '/index.html':

self.send_response(200)

self.send_header('Content-type', 'text/html')

self.end_headers()

# Cr er le contenu HTML avec les donn es POST

content = '<html><body><h1>Donn es POST:</h1><ul>'

for item in post_requests:

content += f'<li>{item}</li>'

content += '</ul></body></html>'

self.wfile.write(content.encode('utf-8'))

return

try:

file_to_open = open(self.path[1:]).read()

self.send_response(200)

self.send_header('Content-type', 'text/html')

self.end_headers()

self.wfile.write(bytes(file_to_open, 'utf-8'))

except FileNotFoundError:

self.send_error(404, 'File Not Found: %s' % self.path)

def do_POST(self):

content_length = int(self.headers['Content-Length'])

post_data = self.rfile.read(content_length).decode('utf-8')

# Ajouter les donn es POST la liste

post_requests.append(post_data)

# Envoyer une rponse HTTP

self.send_response(200)

self.end_headers()

self.wfile.write(b"POST request processed")

class HTTPServerV6(HTTPServer):

address_family = socket.AF_INET6

if __name__ == '__main__':

server_address = ('::', 8888) # ^icoute sur toutes les interfaces IPv6, p>

httpd = HTTPServerV6(server_address, CustomHTTPHandler)

print("Serveur actif sur le port", 8888)

httpd.serve_forever()
</syntaxhighlight>'''Code du client Python :'''<syntaxhighlight lang="python3">
import argparse
import requests
import json

def send_json_to_server(url, json_file):
# Charger les données CSV depuis le fichier spécifié
with open(json_file, 'r') as file:
data = json.load(file)

# En-têtes spécifiant que vous envoyez du CSV
headers = {'Content-Type': 'application/json'}

# Envoie de la requête HTTP POST avec les données
response = requests.post(url, data=json.dumps(data), headers=headers)

# Vérification de la réponse
if response.status_code == 200:
print('Requête envoyée avec succès!')
else:
print(f'Erreur {response.status_code}: {response.text}')

if __name__ == "__main__":
# Configurer les arguments en ligne de commande
parser = argparse.ArgumentParser(description='Client Python pour envoyer des JSON via HTTP.')
parser.add_argument('url', type=str, help='URL du serveur')
parser.add_argument('json_file', type=str, help='Chemin vers le fichier JSON à envoyer')

# Analyser les arguments
args = parser.parse_args()

# Appeler la fonction pour envoyer le JSON au serveur
send_json_to_server(args.url, args.json_file)
</syntaxhighlight>'''Index permettant d'afficher le json de test que nous avons envoyé au serveur :'''<syntaxhighlight lang="html">
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>Page d'Accueil</title>
</head>
<body>
<h1>Bienvenue sur Mon Serveur</h1>
<h2>Données POST reçues:</h2>
<ul id="data">

</ul>
</body>
</html>

</syntaxhighlight>'''Capture montrant l'affichage d'un fichier json (sans aucun sens) envoyé au serveur depuis le client :'''

== Flash du capteur sur le logiciel STM32CubeIDE ==
Le code ci-dessous est la fonction qui est appelé pour le traitement des capteurs. Nous avions décidé de définir le délimiteur de donnée avec un espace.
[[Fichier:CaptureIndexBrenierNguyen.png|centre|Démonstration du protocole HTTP]]

Ci-dessous, on retrouve de la ligne 8 à 12 la configuration du capteur que l'on a défini sur un quadrillage de 8 x 8.<syntaxhighlight lang="c" line="1">
static void MX_53L5A1_SimpleRanging_Process(void)
{
uint32_t Id;

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 */

/* 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);

if (status == BSP_ERROR_NONE)
{
//print_result(&Result);
print_result_IE(&Result);
}

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

HAL_Delay(POLLING_PERIOD);
}
}
</syntaxhighlight>Le code ci-dessous est la fonction qui nous permet d'afficher les données des capteurs via la liaison série.

On observe l'envoie des données avec un séparateur 'espace', puis lorsque les valeurs semblent incohérentes du point de vue du capteur, on envoie arbitrairement un -1 en sortie.

On obtient un jeu de donnée suivant le format : value espace value esapce .... value espace retour chariot (pour chaque lignes/quadrillage sur une ligne)<syntaxhighlight lang="c">
static void print_result_IE(RANGING_SENSOR_Result_t *Result)
{
int8_t j;
int8_t k;
int8_t l;
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("%ld ",(long)Result->ZoneResult[j+k].Distance[l]);
else
printf("%ld ", -1);
}
}
}
printf("\n");
}
</syntaxhighlight>

== Code de récupération de donnée (sur la raspberry) ==
Nous avons le scénario suivant : le capteur qui envoie en continue les données de distance à la raspberry via la liaison série.

Nous avons donc écrit un script python afin de récupérer ces données, les formater dans un fichier format json dans le but de les envoyer sur la VM qui pourra traiter ces données avec l'émulateur obtenue via l'application NanoEdgeAI Studio.

Nous allons vous expliquez le script que nous avons réalisés :<syntaxhighlight lang="python3" line="1">
import serial
from threading import Thread, Event
from time import sleep
import os, sys, signal
import datetime
import glob

interruptAllEvent = Event()

def serial_thread(ser: serial) -> None:
fileName_old = os.path.dirname(__file__) + "/data/sensor_data_start"
while (1):
if (interruptAllEvent.is_set()):
break
fileName = os.path.dirname(__file__) + "/data/sensor_data_" + datetime.datetime.now().strftime("%d_%m_%Y__%H_%M_00") + ".json"

if (fileName_old != fileName):
with open(fileName_old, "a") as fichier:
fichier.write("\"}")

string = str(ser.readline(), encoding='utf-8')

with open(fileName, "a") as fichier:
if (fileName_old != fileName):
fileName_old = fileName
fichier.write("{\"date\":\""+datetime.datetime.now().strftime("%d/%m/%Y-%H:%M:00")+"\",\"csv_file\":\"")

fichier.write(string)

def signal_handler(sig, frame):
interruptAllEvent.set()
return

def main() -> None:
ser = serial.Serial('/dev/ttyACM0', 460800)
thread = Thread(target=serial_thread, args=(ser,))

thread.start()

signal.signal(signal.SIGINT, signal_handler)

sleep(5)
os.remove(os.path.dirname(__file__) + "/data/sensor_data_start")

while (1):
if interruptAllEvent.is_set():
thread.join()
break

sleep(5)

minute = datetime.datetime.now().minute - 1
hours = datetime.datetime.now().hour
if (minute < 0):
minute = minute + 60
hours = hours - 1
try:
with open(os.path.dirname(__file__) + "/data/sensor_data_" + datetime.datetime.now().strftime("%d_%m_%Y__") + str(hours) + "_" + str(minute) + "_00.json", "r+") as fichier:
line = fichier.read()
str(line).replace('\n','\\\n')
fichier.write(line)
except FileNotFoundError:
sleep(60)

file_to_keep = []
for i in range(0,10):
minute = datetime.datetime.now().minute - i
hours = datetime.datetime.now().hour
if (minute < 0):
minute = minute + 60
hours = hours - 1
path_string = os.path.dirname(__file__) + "/data/sensor_data_" + datetime.datetime.now().strftime("%d_%m_%Y__") + str(hours) + "_" + str(minute) + "_00.json"
file_to_keep.append(path_string)

files = glob.glob(os.path.dirname(__file__) + "/data/*")

files_to_remove = []

for file_name in files:
beRemoved = True
for f_keep in file_to_keep:
if file_name == f_keep:
beRemoved = False
break
if beRemoved:
files_to_remove.append(file_name)

for file_name in files_to_remove:
os.remove(file_name)

if __name__ == '__main__':
main()

</syntaxhighlight>

SE5 ECEAI/eceai 2023/2024/Brenier-Nguyen

2024-01-20T13:38:35Z

Tbrenier :

* Séance 1 :
** Création et configuration de la VM sur Chassiron
** Installation de NanoEdge
** Installation de STM32cube
** Installation de l'OS pour la Raspberry dans la carte micro SD
** Prise en main de Nanoedge, de nucléo et de STM32cube
** Début de réflexion sur l'application (métrologie)
*Séance 2:
**Mise en place du serveur python
**Mise en place du client python
**Test réussi de communication entre client et serveur via http
**Programmation de la carte nucléo pour transfert de valeur via liaison série
**Suite réflexion sur l'application (reconnaissance alphabet langue des signes, mouvement)
**Choix de l'application : reconnaissance d'objets appliqué aux fournitures scolaires
**Entraînement des modèles pour les différentes applications cités précédemment
**Finalement : entraînement à la reconnaissance d'objets de fournitures scolaires
*Séance 3:
**Entraînement d'un nouveau modèle.
**Écriture d'un programme permettant de récupérer les données du capteur et de les écrire dans un fichier.
*Séance 4 :
**Essai d'utilisation de la librairie créée grâce à Nanoedge.
**Amélioration du programme python permettant de récupérer les données du capteur.
***Création d'un fichier .txt afin de stocker les données du capteur toutes les minutes.
***Destruction automatique des fichiers de données ayant été crée il y a plus de 10 minutes.
**L’émulateur de la librairie ne fonctionne pas s'il est exécuté dans la raspberry... Nous l'exécutons désormais directement dans notre VM.
**Pour cela nous avons adapter notre programme python afin de récupérer les données à partir d'un json pour traiter ces données dans la VM.
***Création d'un fichier toutes les minutes (contenant au format json la date et les données au format csv)

<b>Code du serveur Python :</b><syntaxhighlight lang="python3">
from http.server import HTTPServer, BaseHTTPRequestHandler

import json

import socket

# Stocker les requ tes POST re ues

post_requests = []

class CustomHTTPHandler(BaseHTTPRequestHandler):

def do_GET(self):

if self.path == '/':

self.path = '/index.html'

if self.path == '/data':

self.send_response(200)

self.send_header('Content-type', 'application/json')

self.end_headers()

self.wfile.write(bytes(json.dumps(post_requests), 'utf-8'))

return

if self.path == '/index.html':

self.send_response(200)

self.send_header('Content-type', 'text/html')

self.end_headers()

# Cr er le contenu HTML avec les donn es POST

content = '<html><body><h1>Donn es POST:</h1><ul>'

for item in post_requests:

content += f'<li>{item}</li>'

content += '</ul></body></html>'

self.wfile.write(content.encode('utf-8'))

return

try:

file_to_open = open(self.path[1:]).read()

self.send_response(200)

self.send_header('Content-type', 'text/html')

self.end_headers()

self.wfile.write(bytes(file_to_open, 'utf-8'))

except FileNotFoundError:

self.send_error(404, 'File Not Found: %s' % self.path)

def do_POST(self):

content_length = int(self.headers['Content-Length'])

post_data = self.rfile.read(content_length).decode('utf-8')

# Ajouter les donn es POST la liste

post_requests.append(post_data)

# Envoyer une rponse HTTP

self.send_response(200)

self.end_headers()

self.wfile.write(b"POST request processed")

class HTTPServerV6(HTTPServer):

address_family = socket.AF_INET6

if __name__ == '__main__':

server_address = ('::', 8888) # ^icoute sur toutes les interfaces IPv6, p>

httpd = HTTPServerV6(server_address, CustomHTTPHandler)

print("Serveur actif sur le port", 8888)

httpd.serve_forever()
</syntaxhighlight>'''Code du client Python :'''<syntaxhighlight lang="python3">
import argparse
import requests
import json

def send_json_to_server(url, json_file):
# Charger les données CSV depuis le fichier spécifié
with open(json_file, 'r') as file:
data = json.load(file)

# En-têtes spécifiant que vous envoyez du CSV
headers = {'Content-Type': 'application/json'}

# Envoie de la requête HTTP POST avec les données
response = requests.post(url, data=json.dumps(data), headers=headers)

# Vérification de la réponse
if response.status_code == 200:
print('Requête envoyée avec succès!')
else:
print(f'Erreur {response.status_code}: {response.text}')

if __name__ == "__main__":
# Configurer les arguments en ligne de commande
parser = argparse.ArgumentParser(description='Client Python pour envoyer des JSON via HTTP.')
parser.add_argument('url', type=str, help='URL du serveur')
parser.add_argument('json_file', type=str, help='Chemin vers le fichier JSON à envoyer')

# Analyser les arguments
args = parser.parse_args()

# Appeler la fonction pour envoyer le JSON au serveur
send_json_to_server(args.url, args.json_file)
</syntaxhighlight>'''Index permettant d'afficher le json de test que nous avons envoyé au serveur :'''<syntaxhighlight lang="html">
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>Page d'Accueil</title>
</head>
<body>
<h1>Bienvenue sur Mon Serveur</h1>
<h2>Données POST reçues:</h2>
<ul id="data">

</ul>
</body>
</html>

</syntaxhighlight>'''Capture montrant l'affichage d'un fichier json (sans aucun sens) envoyé au serveur depuis le client :'''

== Flash du capteur sur le logiciel STM32CubeIDE ==
Le code ci-dessous est la fonction qui est appelé pour le traitement des capteurs. Nous avions décidé de définir le délimiteur de donnée avec un espace.
[[Fichier:CaptureIndexBrenierNguyen.png|vignette|Démonstration du protocole HTTP]]

Ci-dessous, on retrouve de la ligne 8 à 12 la configuration du capteur que l'on a défini sur un quadrillage de 8 x 8.<syntaxhighlight lang="c" line="1">
static void MX_53L5A1_SimpleRanging_Process(void)
{
uint32_t Id;

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 */

/* 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);

if (status == BSP_ERROR_NONE)
{
//print_result(&Result);
print_result_IE(&Result);
}

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

HAL_Delay(POLLING_PERIOD);
}
}
</syntaxhighlight>Le code ci-dessous est la fonction qui nous permet d'afficher les données des capteurs via la liaison série.

On observe l'envoie des données avec un séparateur 'espace', puis lorsque les valeurs semblent incohérentes du point de vue du capteur, on envoie arbitrairement un -1 en sortie.

On obtient un jeu de donnée suivant le format : value espace value esapce .... value espace retour chariot (pour chaque lignes/quadrillage sur une ligne)<syntaxhighlight lang="c">
static void print_result_IE(RANGING_SENSOR_Result_t *Result)
{
int8_t j;
int8_t k;
int8_t l;
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("%ld ",(long)Result->ZoneResult[j+k].Distance[l]);
else
printf("%ld ", -1);
}
}
}
printf("\n");
}
</syntaxhighlight>

== Code de récupération de donnée (sur la raspberry) ==
Nous avons le scénario suivant : le capteur qui envoie en continue les données de distance à la raspberry via la liaison série.

Nous avons donc écrit un script python afin de récupérer ces données, les formater dans un fichier format json dans le but de les envoyer sur la VM qui pourra traiter ces données avec l'émulateur obtenue via l'application NanoEdgeAI Studio.

Nous allons vous expliquez le script que nous avons réalisés :<syntaxhighlight lang="python3" line="1">
import serial
from threading import Thread, Event
from time import sleep
import os, sys, signal
import datetime
import glob

interruptAllEvent = Event()

def serial_thread(ser: serial) -> None:
fileName_old = os.path.dirname(__file__) + "/data/sensor_data_start"
while (1):
if (interruptAllEvent.is_set()):
break
fileName = os.path.dirname(__file__) + "/data/sensor_data_" + datetime.datetime.now().strftime("%d_%m_%Y__%H_%M_00") + ".json"

if (fileName_old != fileName):
with open(fileName_old, "a") as fichier:
fichier.write("\"}")

string = str(ser.readline(), encoding='utf-8')

with open(fileName, "a") as fichier:
if (fileName_old != fileName):
fileName_old = fileName
fichier.write("{\"date\":\""+datetime.datetime.now().strftime("%d/%m/%Y-%H:%M:00")+"\",\"csv_file\":\"")

fichier.write(string)

def signal_handler(sig, frame):
interruptAllEvent.set()
return

def main() -> None:
ser = serial.Serial('/dev/ttyACM0', 460800)
thread = Thread(target=serial_thread, args=(ser,))

thread.start()

signal.signal(signal.SIGINT, signal_handler)

sleep(5)
os.remove(os.path.dirname(__file__) + "/data/sensor_data_start")

while (1):
if interruptAllEvent.is_set():
thread.join()
break

sleep(5)

minute = datetime.datetime.now().minute - 1
hours = datetime.datetime.now().hour
if (minute < 0):
minute = minute + 60
hours = hours - 1
try:
with open(os.path.dirname(__file__) + "/data/sensor_data_" + datetime.datetime.now().strftime("%d_%m_%Y__") + str(hours) + "_" + str(minute) + "_00.json", "r+") as fichier:
line = fichier.read()
str(line).replace('\n','\\\n')
fichier.write(line)
except FileNotFoundError:
sleep(60)

file_to_keep = []
for i in range(0,10):
minute = datetime.datetime.now().minute - i
hours = datetime.datetime.now().hour
if (minute < 0):
minute = minute + 60
hours = hours - 1
path_string = os.path.dirname(__file__) + "/data/sensor_data_" + datetime.datetime.now().strftime("%d_%m_%Y__") + str(hours) + "_" + str(minute) + "_00.json"
file_to_keep.append(path_string)

files = glob.glob(os.path.dirname(__file__) + "/data/*")

files_to_remove = []

for file_name in files:
beRemoved = True
for f_keep in file_to_keep:
if file_name == f_keep:
beRemoved = False
break
if beRemoved:
files_to_remove.append(file_name)

for file_name in files_to_remove:
os.remove(file_name)

if __name__ == '__main__':
main()

</syntaxhighlight>

SE5 ECEAI/eceai 2023/2024/Brenier-Nguyen

2024-01-20T13:36:44Z

Tbrenier :

* Séance 1 :
** Création et configuration de la VM sur Chassiron
** Installation de NanoEdge
** Installation de STM32cube
** Installation de l'OS pour la Raspberry dans la carte micro SD
** Prise en main de Nanoedge, de nucléo et de STM32cube
** Début de réflexion sur l'application (métrologie)
*Séance 2:
**Mise en place du serveur python
**Mise en place du client python
**Test réussi de communication entre client et serveur via http
**Programmation de la carte nucléo pour transfert de valeur via liaison série
**Suite réflexion sur l'application (reconnaissance alphabet langue des signes, mouvement)
**Choix de l'application : reconnaissance d'objets appliqué aux fournitures scolaires
**Entraînement des modèles pour les différentes applications cités précédemment
**Finalement : entraînement à la reconnaissance d'objets de fournitures scolaires
*Séance 3:
**Entraînement d'un nouveau modèle.
**Écriture d'un programme permettant de récupérer les données du capteur et de les écrire dans un fichier.
*Séance 4 :
**Essai d'utilisation de la librairie créée grâce à Nanoedge.
**Amélioration du programme python permettant de récupérer les données du capteur.
***Création d'un fichier .txt afin de stocker les données du capteur toutes les minutes.
***Destruction automatique des fichiers de données ayant été crée il y a plus de 10 minutes.
**L’émulateur de la librairie ne fonctionne pas s'il est exécuté dans la raspberry... Nous l'exécutons désormais directement dans notre VM.
**Pour cela nous avons adapter notre programme python afin de récupérer les données à partir d'un json pour traiter ces données dans la VM.
***Création d'un fichier toutes les minutes (contenant au format json la date et les données au format csv)

<b>Code du serveur Python :</b><syntaxhighlight lang="python3">
from http.server import HTTPServer, BaseHTTPRequestHandler

import json

import socket

# Stocker les requ tes POST re ues

post_requests = []

class CustomHTTPHandler(BaseHTTPRequestHandler):

def do_GET(self):

if self.path == '/':

self.path = '/index.html'

if self.path == '/data':

self.send_response(200)

self.send_header('Content-type', 'application/json')

self.end_headers()

self.wfile.write(bytes(json.dumps(post_requests), 'utf-8'))

return

if self.path == '/index.html':

self.send_response(200)

self.send_header('Content-type', 'text/html')

self.end_headers()

# Cr er le contenu HTML avec les donn es POST

content = '<html><body><h1>Donn es POST:</h1><ul>'

for item in post_requests:

content += f'<li>{item}</li>'

content += '</ul></body></html>'

self.wfile.write(content.encode('utf-8'))

return

try:

file_to_open = open(self.path[1:]).read()

self.send_response(200)

self.send_header('Content-type', 'text/html')

self.end_headers()

self.wfile.write(bytes(file_to_open, 'utf-8'))

except FileNotFoundError:

self.send_error(404, 'File Not Found: %s' % self.path)

def do_POST(self):

content_length = int(self.headers['Content-Length'])

post_data = self.rfile.read(content_length).decode('utf-8')

# Ajouter les donn es POST la liste

post_requests.append(post_data)

# Envoyer une rponse HTTP

self.send_response(200)

self.end_headers()

self.wfile.write(b"POST request processed")

class HTTPServerV6(HTTPServer):

address_family = socket.AF_INET6

if __name__ == '__main__':

server_address = ('::', 8888) # ^icoute sur toutes les interfaces IPv6, p>

httpd = HTTPServerV6(server_address, CustomHTTPHandler)

print("Serveur actif sur le port", 8888)

httpd.serve_forever()
</syntaxhighlight>'''Code du client Python :'''<syntaxhighlight lang="python3">
import argparse
import requests
import json

def send_json_to_server(url, json_file):
# Charger les données CSV depuis le fichier spécifié
with open(json_file, 'r') as file:
data = json.load(file)

# En-têtes spécifiant que vous envoyez du CSV
headers = {'Content-Type': 'application/json'}

# Envoie de la requête HTTP POST avec les données
response = requests.post(url, data=json.dumps(data), headers=headers)

# Vérification de la réponse
if response.status_code == 200:
print('Requête envoyée avec succès!')
else:
print(f'Erreur {response.status_code}: {response.text}')

if __name__ == "__main__":
# Configurer les arguments en ligne de commande
parser = argparse.ArgumentParser(description='Client Python pour envoyer des JSON via HTTP.')
parser.add_argument('url', type=str, help='URL du serveur')
parser.add_argument('json_file', type=str, help='Chemin vers le fichier JSON à envoyer')

# Analyser les arguments
args = parser.parse_args()

# Appeler la fonction pour envoyer le JSON au serveur
send_json_to_server(args.url, args.json_file)
</syntaxhighlight>'''Index permettant d'afficher le json de test que nous avons envoyé au serveur :'''<syntaxhighlight lang="html">
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>Page d'Accueil</title>
</head>
<body>
<h1>Bienvenue sur Mon Serveur</h1>
<h2>Données POST reçues:</h2>
<ul id="data">

</ul>
</body>
</html>

</syntaxhighlight>'''Capture montrant l'affichage d'un fichier json (sans aucun sens) envoyé au serveur depuis le client :'''
[[Fichier:CaptureIndexBrenierNguyen.png|vignette|Démonstration du protocole HTTP]]

== Flash du capteur sur le logiciel STM32CubeIDE ==
Le code ci-dessous est la fonction qui est appelé pour le traitement des capteurs. Nous avions décidé de définir le délimiteur de donnée avec un espace.

Ci-dessous, on retrouve de la ligne 8 à 12 la configuration du capteur que l'on a défini sur un quadrillage de 8 x 8.<syntaxhighlight lang="c" line="1">
static void MX_53L5A1_SimpleRanging_Process(void)
{
uint32_t Id;

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 */

/* 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);

if (status == BSP_ERROR_NONE)
{
//print_result(&Result);
print_result_IE(&Result);
}

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

HAL_Delay(POLLING_PERIOD);
}
}
</syntaxhighlight>Le code ci-dessous est la fonction qui nous permet d'afficher les données des capteurs via la liaison série.

On observe l'envoie des données avec un séparateur 'espace', puis lorsque les valeurs semblent incohérentes du point de vue du capteur, on envoie arbitrairement un -1 en sortie.

On obtient un jeu de donnée suivant le format : value espace value esapce .... value espace retour chariot (pour chaque lignes/quadrillage sur une ligne)<syntaxhighlight lang="c">
static void print_result_IE(RANGING_SENSOR_Result_t *Result)
{
int8_t j;
int8_t k;
int8_t l;
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("%ld ",(long)Result->ZoneResult[j+k].Distance[l]);
else
printf("%ld ", -1);
}
}
}
printf("\n");
}
</syntaxhighlight>

== Code de récupération de donnée (sur la raspberry) ==
Nous avons le scénario suivant : le capteur qui envoie en continue les données de distance à la raspberry via la liaison série.

Nous avons donc écrit un script python afin de récupérer ces données, les formater dans un fichier format json dans le but de les envoyer sur la VM qui pourra traiter ces données avec l'émulateur obtenue via l'application NanoEdgeAI Studio.

Nous allons vous expliquez le script que nous avons réalisés :<syntaxhighlight lang="python3" line="1">
import serial
from threading import Thread, Event
from time import sleep
import os, sys, signal
import datetime
import glob

interruptAllEvent = Event()

def serial_thread(ser: serial) -> None:
fileName_old = os.path.dirname(__file__) + "/data/sensor_data_start"
while (1):
if (interruptAllEvent.is_set()):
break
fileName = os.path.dirname(__file__) + "/data/sensor_data_" + datetime.datetime.now().strftime("%d_%m_%Y__%H_%M_00") + ".json"

if (fileName_old != fileName):
with open(fileName_old, "a") as fichier:
fichier.write("\"}")

string = str(ser.readline(), encoding='utf-8')

with open(fileName, "a") as fichier:
if (fileName_old != fileName):
fileName_old = fileName
fichier.write("{\"date\":\""+datetime.datetime.now().strftime("%d/%m/%Y-%H:%M:00")+"\",\"csv_file\":\"")

fichier.write(string)

def signal_handler(sig, frame):
interruptAllEvent.set()
return

def main() -> None:
ser = serial.Serial('/dev/ttyACM0', 460800)
thread = Thread(target=serial_thread, args=(ser,))

thread.start()

signal.signal(signal.SIGINT, signal_handler)

sleep(5)
os.remove(os.path.dirname(__file__) + "/data/sensor_data_start")

while (1):
if interruptAllEvent.is_set():
thread.join()
break

sleep(5)

minute = datetime.datetime.now().minute - 1
hours = datetime.datetime.now().hour
if (minute < 0):
minute = minute + 60
hours = hours - 1
try:
with open(os.path.dirname(__file__) + "/data/sensor_data_" + datetime.datetime.now().strftime("%d_%m_%Y__") + str(hours) + "_" + str(minute) + "_00.json", "r+") as fichier:
line = fichier.read()
str(line).replace('\n','\\\n')
fichier.write(line)
except FileNotFoundError:
sleep(60)

file_to_keep = []
for i in range(0,10):
minute = datetime.datetime.now().minute - i
hours = datetime.datetime.now().hour
if (minute < 0):
minute = minute + 60
hours = hours - 1
path_string = os.path.dirname(__file__) + "/data/sensor_data_" + datetime.datetime.now().strftime("%d_%m_%Y__") + str(hours) + "_" + str(minute) + "_00.json"
file_to_keep.append(path_string)

files = glob.glob(os.path.dirname(__file__) + "/data/*")

files_to_remove = []

for file_name in files:
beRemoved = True
for f_keep in file_to_keep:
if file_name == f_keep:
beRemoved = False
break
if beRemoved:
files_to_remove.append(file_name)

for file_name in files_to_remove:
os.remove(file_name)

if __name__ == '__main__':
main()

</syntaxhighlight>

Atelier SysRes SE5 2023/2024 E7

2024-01-16T16:19:50Z

Tbrenier : /* Cassage de clef WEP d'un point d'accès WiFi */

=== Cassage de clef WEP d'un point d'accès WiFi ===
Voir détails sur : [[Atelier SysRes SE5 2023/2024 E6|Cahier n°6]] [[Fichier:Crack clef WEP.png|vignette|1561x1561px|néant]]

=== Cassage de mot de passe WPA-PSK par force brute ===
Voir détails sur : [[Atelier SysRes SE5 2023/2024 E6|Cahier n°6]]

[[Fichier:Crack wifi wpa.png|sans_cadre|762x762px]]

Atelier SysRes SE5 2023/2024 E7

2024-01-16T16:17:09Z

Tbrenier : /* Cassage de clef WEP d'un point d'accès WiFi */

=== Cassage de clef WEP d'un point d'accès WiFi ===
Voir détails sur : [[Fichier:Crack clef WEP.png|vignette|1561x1561px|néant]]

=== Cassage de mot de passe WPA-PSK par force brute ===
Voir détails sur :

[[Fichier:Crack wifi wpa.png|sans_cadre|762x762px]]

Atelier SysRes SE5 2023/2024 E7

2024-01-16T16:16:51Z

Tbrenier : /* Cassage de clef WEP d'un point d'accès WiFi */

Atelier SysRes SE5 2023/2024 E7

2024-01-16T16:16:08Z

Tbrenier : /* Cassage de clef WEP d'un point d'accès WiFi */

Atelier SysRes SE5 2023/2024 E7

2024-01-16T16:15:17Z

Tbrenier : /* Cassage de clef WEP d'un point d'accès WiFi */

=== Cassage de clef WEP d'un point d'accès WiFi ===
Voir détails sur : [[Atelier SysRes SE5 2023/2024 E7 |Cahier n°7]][[Fichier:Crack clef WEP.png|vignette|1561x1561px|néant]]

=== Cassage de mot de passe WPA-PSK par force brute ===
Voir détails sur : [[Atelier SysRes SE5 2023/2024 E7 |Cahier n°7]]

[[Fichier:Crack wifi wpa.png|sans_cadre|762x762px]]

Atelier SysRes SE5 2023/2024 E7

2024-01-16T16:13:27Z

Tbrenier : /* Cassage de mot de passe WPA-PSK par force brute */

=== Cassage de clef WEP d'un point d'accès WiFi ===
Voir détails sur :[[Fichier:Crack clef WEP.png|vignette|1561x1561px|néant]]

=== Cassage de mot de passe WPA-PSK par force brute ===
Voir détails sur :

[[Fichier:Crack wifi wpa.png|sans_cadre|762x762px]]

Atelier SysRes SE5 2023/2024 E7

2024-01-16T16:13:10Z

Tbrenier : /* Cassage de clef WEP d'un point d'accès WiFi */

Atelier SysRes SE5 2023/2024 E7

2024-01-16T16:12:44Z

Tbrenier : /* Cassage de mot de passe WPA-PSK par force brute */

Atelier SysRes SE5 2023/2024 E7

2024-01-16T16:12:33Z

Tbrenier : /* Cassage de clef WEP d'un point d'accès WiFi */

=== Cassage de clef WEP d'un point d'accès WiFi ===
[[Fichier:Crack clef WEP.png|vignette|1561x1561px|néant]]

=== Cassage de mot de passe WPA-PSK par force brute ===

Atelier SysRes SE5 2023/2024 E7

2024-01-16T16:10:44Z

Tbrenier :

=== Cassage de clef WEP d'un point d'accès WiFi ===
[[Fichier:Crack clef WEP.png|vignette|1561x1561px|néant]]

Atelier SysRes SE5 2023/2024 E7

2024-01-16T16:09:55Z

Tbrenier :

[[Fichier:Crack clef WEP.png|vignette|1561x1561px|néant]]

Atelier SysRes SE5 2023/2024 E7

2024-01-16T15:52:10Z

Tbrenier : Page vide créée

Atelier SysRes SE5 2023/2024 E6

2024-01-16T15:51:56Z

Tbrenier : Page vide créée

SE5 système/réseau 2023/2024

2024-01-15T07:03:21Z

Tbrenier : /* Répartition des binômes en PRA */

= 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 || Konstantin PATRIKEEV
|-
| zabeth22 || Maxime Balbastre
|-
| zabeth26 || François NAUDOT
|-
| zabeth27 || Karl HABRE
|-
| zabeth28 || Rémi FARAULT
|-
| zabeth30 || Prénom Nom
|-
|}

== Répartition des binômes en PRA ==

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|| || || Baloo|| || Elias SIMON
|-
| [[Atelier SysRes SE5 2023/2024 E3 | Cahier n°3]]
| Mustafar (Mustafare)|| || mustafare.lol|| Baloo|| 193.48.57.189|| Mathis RIFFAUT
|-
| [[Atelier SysRes SE5 2023/2024 E4 | Cahier n°4]]
| Dagobah|| || dagobah.lol|| Aladin|| || Dann RODENBURG
|-
| [[Atelier SysRes SE5 2023/2024 E5 | Cahier n°5]]
| Motis|| || || Dingo|| || Mohammed Halaoui
|-
| [[Atelier SysRes SE5 2023/2024 E6 | Cahier n°6]]
| bogano|| || || Timon|| || Benjamin Nguyen
|-
| [[Atelier SysRes SE5 2023/2024 E7 | Cahier n°7]]
| Takobo|| || <code>takobo.lol</code>|| Timon|| 193.48.57.184|| Timothé Brenier
|-
| [[Atelier SysRes SE5 2023/2024 E8 | Cahier n°8]]
| Fondor|| || || mushu|| 193.48.57.190|| Florian Vallée
|-
| [[Atelier SysRes SE5 2023/2024 E9 | Cahier n°9]]
| hoth|| || || BlancheNeige|| 193.48.57.187|| Haitam Blgrim
|-
| [[Atelier SysRes SE5 2023/2024 E10 | Cahier n°10]]
| Abafar|| || abafar.lol|| Aladin|| 193.48.57.179|| Amine SELLALI
|-
| [[Atelier SysRes SE5 2023/2024 E11 | Cahier n°11]]
| Rotia|| || || DIngo|| 193.48.57.181|| Rémi Farault
|-
| [[Atelier SysRes SE5 2023/2024 E12 | Cahier n°12]]
| jedha|| || || judy|| 193.48.57.182|| Julien Charleux
|-
| [[Atelier SysRes SE5 2023/2024 E13 | Cahier n°13]]
| Bogden|| || || BlancheNeige|| || Black Baptiste
|-
| [[Atelier SysRes SE5 2023/2024 E14 | Cahier n°14]]
| endor|| 10.10.10.10|| || mickey|| 193.48.57.188 / 10.10.10.1|| Maël Delaby
|-
| [[Atelier SysRes SE5 2023/2024 E15 | Cahier n°15]]
| jiruus|| 192.168.19.3|| jiruus.lol|| cruella|| || Jeanne Delcourt
|-
| [[Atelier SysRes SE5 2023/2024 E16 | Cahier n°16]]
| exegol|| 192.168.19.2|| exegol.lol|| cruella|| 193.48.57.186 /
192.168.19.1
| 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|| 192.168.18.2|| naboo.lol|| bouh|| 193.48.57.180 / 192.168.18.1|| Chloé Lemaire
|-
| [[Atelier SysRes SE5 2023/2024 E19 | Cahier n°19]]
| geonosis|| 192.168.18.3|| geonosis.lol|| bouh|| || Gabriel THOMAS
|-
| [[Atelier SysRes SE5 2023/2024 E20 | Cahier n°20]]
| alderaan|| || || Jafar|| 193.48.57.183|| Albin MOUTON
|-
| [[Atelier SysRes SE5 2023/2024 E21 | Cahier n°21]]
| kesh|| || || Judy|| || Konstantin Patrikeev
|-
| [[Atelier SysRes SE5 2023/2024 E22 | Cahier n°22]]
| kashyyyk|| || || mushu|| || Maxime BALBASTRE
|-
| [[Atelier SysRes SE5 2023/2024 E23 | Cahier n°23]]
| Felucia|| 192.168.26.2|| || Ursula|| 193.48.57.185 / 192.168.26.1|| François NAUDOT
|-
| [[Atelier SysRes SE5 2023/2024 E24 | Cahier n°24]]
| Pelagon|| 10.10.10.11|| || mickey|| 193.48.57.188 / 10.10.10.1|| Paul Amoros
|-
|[[Atelier SysRes SE5 2023/2024 E24 | Cahier n°25]]
|Kalee
|192.168.26.3
|kalee.lol
|Ursula
|
|Karl Habre
|}

== Contrôle continu ==

=== Contrôle du 20/11/2023 ===

A noter qu'aucune machine, quelle soit de service ou mandataire, ne peut avoir accès à Internet vu qu'aucun effort n'a été fait pour relier le serveur <code>capbreton</code> au réseau SE5.

Machines de service.

{| class="wikitable"
! Elève !! Nom machine !! Configuration IP
|-
| Elom || Elias SIMON || une seule interface dans le <code>.cfg</code> (CV SE5), pas de configuration IP
|-
| Mustafar|| Mathis RIFFAUT || une seule interface dans le <code>.cfg</code> (CV SE5), pas de configuration IP
|-
| Dagobah|| Dann RODENBURG || une seule interface dans le <code>.cfg</code> (CV SE5), pas de configuration IP
|-
| Motis || Mohammed Halaoui || une seule interface dans le <code>.cfg</code> (CV SE5), pas de configuration IP
|-
| bogano || Benjamin Nguyen || une seule interface dans le <code>.cfg</code> (CV SE5), pas de configuration IP
|-
| Takobo || Timothé Brenier || une seule interface dans le <code>.cfg</code> (CV SE5), pas de configuration IP
|-
| Fondor || Florian Vallée || une seule interface dans le <code>.cfg</code> (CV SE5), pas de configuration IP
|-
| hoth || Haitam Blgrim || une seule interface dans le <code>.cfg</code> (CV SE5), pas de configuration IP
|-
| Abafar || Amine SELLALI || une seule interface dans le <code>.cfg</code> (CV SE5), pas de configuration IP
|-
| Rotia || Rémi Farault || une seule interface dans le <code>.cfg</code> (CV SE5), pas de configuration IP
|-
| jedha || Julien Charleux || une seule interface dans le <code>.cfg</code> (CV SE5), pas de configuration IP
|-
| Bogden || Black Baptiste || une seule interface dans le <code>.cfg</code> (CV SE5), pas de configuration IP
|-
| jiruus || Jeanne Delcourt || une seule interface dans le <code>.cfg</code> (CV SE5), pas de configuration IP
|-
| exegol || Estelle Godard || une seule interface dans le <code>.cfg</code> (CV SE5), pas de configuration IP
|-
| Jakku || Jason DELANNOY || une seule interface dans le <code>.cfg</code> (CV SE5), pas de configuration IP
|-
| naboo || Chloé Lemaire || une seule interface dans le <code>.cfg</code> (CV SE5), pas de configuration IP
|-
| geonosis || Gabriel THOMAS || une seule interface dans le <code>.cfg</code> (CV SE5), pas de configuration IP
|-
| alderaan || Albin MOUTON || une seule interface dans le <code>.cfg</code> (CV SE5), pas de configuration IP
|-
| kesh || Konstantin Patrikeev || une seule interface dans le <code>.cfg</code> (CV SE5), pas de configuration IP
|-
| kashyyyk || Maxime BALBASTRE || une seule interface dans le <code>.cfg</code> (CV SE5), pas de configuration IP
|-
| Felucia || François NAUDOT || une seule interface dans le <code>.cfg</code> (CV SE5), pas de configuration IP
|-
|}

Machines mandataires.

{| class="wikitable"
! Elèves !! Nom machine !! Configuration IP
|-
| Elias SIMON & Mathis RIFFAUT || Baloo || une seule interface dans le <code>.cfg</code> (CV SE5), aucun CV privé, pas de configuration IP
|-
| Dann RODENBURG & Amine SELLALI || Aladin || une seule interface dans le <code>.cfg</code> (CV SE5), aucun CV privé, pas de configuration IP
|-
| Mohammed Halaoui & Rémi Farault || Dingo || une seule interface dans le <code>.cfg</code> (CV SE5), aucun CV privé, pas de configuration IP
|-
| Benjamin Nguyen & Timothé Brenier || Timon || une seule interface dans le <code>.cfg</code> (CV SE5), aucun CV privé, pas de configuration IP
|-
| Florian Vallée & Maxime BALBASTRE || mushu || une seule interface dans le <code>.cfg</code> (CV SE5), aucun CV privé, pas de configuration IP
|-
| Haitam Blgrim & Black Baptiste || BlancheNeige || une seule interface dans le <code>.cfg</code> (CV SE5), aucun CV privé, pas de configuration IP
|-
| Jeanne Delcourt & Estelle Godard || cruella || une seule interface dans le <code>.cfg</code> (CV SE5), aucun CV privé, pas de configuration IP
|-
| Jason DELANNOY & Albin MOUTON || Jafar || une seule interface dans le <code>.cfg</code> (CV SE5), aucun CV privé, pas de configuration IP
|-
| Chloé Lemaire & Gabriel THOMAS || bouh || une seule interface dans le <code>.cfg</code> (CV SE5), aucun CV privé, pas de configuration IP
|-
| Konstantin Patrikeev & Julien Charleux || judy || une seule interface dans le <code>.cfg</code> (CV SE5), aucun CV privé, pas de configuration IP
|-
| François NAUDOT & Karl HABRE || Ursula|| rien
|-
|}

Liste des machines

Elom Mustafar dagobah Motis bogano Takobo Fondor hoth abafar Rotia jedha Bogden jiruus exegol Jakku naboo geonosis alderaan kesh kashyyyk Felucia

Baloo aladin Dingo Timon mushu BlancheNeige cruella Jafar bouh judy

=== Contrôle du 03/12/2023 ===

Le serveur <code>capbreton</code> a été relié au réseau SE5 par <code>naboo</code>.

Il est normal de ne pas avoir d'adresse IPv4 sur la machine de services pour l'interface sur le commutateur virtuel. Par contre, avec mise en place de la mascarade sur la machine mandataire, il doit être possible, pour la machine de services, de se connecter à Internet en IPv4.

{| class="wikitable"
! Elève !! Nom machine !! Configuration IP
|-
| Elom || Elias SIMON
| IPv4 sur CV : 10.0.69.220, pas d'IPv4 sur SE5, IPv6 sur SE5 : 2001:660:4401:60b0:216:3eff:fe0f:b26d, pas de connexion à Internet en IPv4, connexion à Internet en IPv6 possible, pas de résolution DNS fonctionnelle
|-
| Mustafar|| Mathis RIFFAUT
| IPv4 sur CV : 10.0.69.165, pas d'IPv4 sur SE5, IPv6 sur SE5 : 2001:660:4401:60b0:216:3eff:fea9:f79, pas de connexion à Internet en IPv4, connexion à Internet en IPv6 possible, pas de résolution DNS fonctionnelle
|-
| Dagobah|| Dann RODENBURG
| IPv4 sur CV : 10.0.69.205, pas d'IPv4 sur SE5, IPv6 sur SE5 : 2001:660:4401:60b0:216:3eff:fe53:7d33, pas de connexion à Internet en IPv4, connexion à Internet en IPv6 possible, pas de résolution DNS fonctionnelle
|-
| Motis || Mohammed Halaoui
| IPv4 sur CV : 10.0.69.195, pas d'IPv4 sur SE5, IPv6 sur SE5 : 2001:660:4401:60b0:216:3eff:fe7c:2d6a, pas de connexion à Internet en IPv4, connexion à Internet en IPv6 possible, pas de résolution DNS fonctionnelle
|-
| bogano || Benjamin Nguyen
| IPv4 sur CV : 10.0.69.245, pas d'IPv4 sur SE5, IPv6 sur SE5 : 2001:660:4401:60b0:216:3eff:fe62:6960, pas de connexion à Internet en IPv4, connexion à Internet en IPv6 possible, pas de résolution DNS fonctionnelle
|-
| Takobo || Timothé Brenier
| IPv4 sur CV : 10.0.69.181, pas d'IPv4 sur SE5, IPv6 sur SE5 : 2001:660:4401:60b0:216:3eff:fe93:8c48, pas de connexion à Internet en IPv4, connexion à Internet en IPv6 possible, pas de résolution DNS fonctionnelle
|-
| Fondor || Florian Vallée
| IPv4 sur CV : 10.0.69.200, pas d'IPv4 sur SE5, IPv6 sur SE5 : 2001:660:4401:60b0:216:3eff:fe2d:82bf, pas de connexion à Internet en IPv4, connexion à Internet en IPv6 possible, pas de résolution DNS fonctionnelle
|-
| hoth || Haitam Blgrim
| IPv4 sur CV : 10.0.69.157, pas d'IPv4 sur SE5, IPv6 sur SE5 : 2001:660:4401:60b0:216:3eff:fee8:4736, pas de connexion à Internet en IPv4, connexion à Internet en IPv6 possible, pas de résolution DNS fonctionnelle
|-
| Abafar || Amine SELLALI
| IPv4 sur CV : 10.0.69.233, pas d'IPv4 sur SE5, IPv6 sur SE5 : 2001:660:4401:60b0:216:3eff:feae:bcbb, pas de connexion à Internet en IPv4, connexion à Internet en IPv6 possible, pas de résolution DNS fonctionnelle
|-
| Rotia || Rémi Farault
| IPv4 sur CV : 10.0.69.130, pas d'IPv4 sur SE5, IPv6 sur SE5 : 2001:660:4401:60b0:216:3eff:fe2e:ec48, pas de connexion à Internet en IPv4, connexion à Internet en IPv6 possible, pas de résolution DNS fonctionnelle
|-
| jedha || Julien Charleux
| IPv4 sur CV : 10.0.69.221, pas d'IPv4 sur SE5, IPv6 sur SE5 : 2001:660:4401:60b0:216:3eff:fef6:364f, pas de connexion à Internet en IPv4, connexion à Internet en IPv6 possible, pas de résolution DNS fonctionnelle
|-
| Bogden || Black Baptiste
| IPv4 sur CV : 10.0.69.246, pas d'IPv4 sur SE5, IPv6 sur SE5 : 2001:660:4401:60b0:216:3eff:fe67:89fd, pas de connexion à Internet en IPv4, connexion à Internet en IPv6 possible, pas de résolution DNS fonctionnelle
|-
| jiruus || Jeanne Delcourt
| IPv4 sur CV : 10.0.69.247, pas d'IPv4 sur SE5, IPv6 sur SE5 : 2001:660:4401:60b0:216:3eff:fe9c:6f0e, pas de connexion à Internet en IPv4, connexion à Internet en IPv6 possible, pas de résolution DNS fonctionnelle
|-
| exegol || Estelle Godard
| IPv4 sur CV : 10.0.69.147, pas d'IPv4 sur SE5, IPv6 sur SE5 : 2001:660:4401:60b0:216:3eff:fe17:bc38, pas de connexion à Internet en IPv4, connexion à Internet en IPv6 possible, pas de résolution DNS fonctionnelle
|-
| Jakku || Jason DELANNOY
| IPv4 sur CV : 10.0.69.136, pas d'IPv4 sur SE5, IPv6 sur SE5 : 2001:660:4401:60b0:216:3eff:fee1:1e4d, pas de connexion à Internet en IPv4, connexion à Internet en IPv6 possible, pas de résolution DNS fonctionnelle
|-
| naboo || Chloé Lemaire
| IPv4 sur CV : 192.168.18.2, pas d'IPv4 sur SE5, IPv6 sur SE5 : 2001:660:4401:60b0:216:3eff:fef2:7e2, pas de connexion à Internet en IPv4, connexion à Internet en IPv6 possible, résolution DNS fonctionnelle
|-
| geonosis || Gabriel THOMAS
| IPv4 sur CV : 10.0.69.231, pas d'IPv4 sur SE5, IPv6 sur SE5 : 2001:660:4401:60b0:216:3eff:feb0:b140, pas de connexion à Internet en IPv4, connexion à Internet en IPv6 possible, pas de résolution DNS fonctionnelle
|-
| alderaan || Albin MOUTON
| IPv4 sur CV : 10.0.69.106, pas d'IPv4 sur SE5, IPv6 sur SE5 : 2001:660:4401:60b0:216:3eff:fe97:2114, pas de connexion à Internet en IPv4, connexion à Internet en IPv6 possible, pas de résolution DNS fonctionnelle
|-
| kesh || Konstantin Patrikeev
| IPv4 sur CV : 10.0.69.222, pas d'IPv4 sur SE5, IPv6 sur SE5 : 2001:660:4401:60b0:216:3eff:fe10:e2cb, pas de connexion à Internet en IPv4, connexion à Internet en IPv6 possible, pas de résolution DNS fonctionnelle
|-
| kashyyyk || Maxime BALBASTRE
| IPv4 sur CV : 10.0.69.240, pas d'IPv4 sur SE5, IPv6 sur SE5 : 2001:660:4401:60b0:216:3eff:feca:73e7, pas de connexion à Internet en IPv4, connexion à Internet en IPv6 possible, pas de résolution DNS fonctionnelle
|-
| Felucia || François NAUDOT
| IPv4 sur CV : 10.0.69.139, pas d'IPv4 sur SE5, IPv6 sur SE5 : 2001:660:4401:60b0:216:3eff:fe89:460a, pas de connexion à Internet en IPv4, connexion à Internet en IPv6 possible, pas de résolution DNS fonctionnelle
|-
|}

Machines mandataires.

{| class="wikitable"
! Elèves !! Nom machine !! Configuration IP
|-
| Elias SIMON & Mathis RIFFAUT || Baloo
| IPv4 sur CV : 10.0.69.152, pas d'IPv4 sur SE5, IPv6 sur SE5 : 2001:660:4401:60b0:216:3eff:fec8:5379, pas de connexion à Internet en IPv4, connexion à Internet en IPv6 possible, pas de résolution DNS fonctionnelle
|-
| Dann RODENBURG & Amine SELLALI || Aladin
| IPv4 sur CV : 10.0.69.107, pas d'IPv4 sur SE5, IPv6 sur SE5 : 2001:660:4401:60b0:216:3eff:fe6b:c000, pas de connexion à Internet en IPv4, connexion à Internet en IPv6 possible, pas de résolution DNS fonctionnelle
|-
| Mohammed Halaoui & Rémi Farault || Dingo
| IPv4 sur CV : 10.0.69.156, pas d'IPv4 sur SE5, IPv6 sur SE5 : 2001:660:4401:60b0:216:3eff:fe0d:4f9c, pas de connexion à Internet en IPv4, connexion à Internet en IPv6 possible, pas de résolution DNS fonctionnelle
|-
| Benjamin Nguyen & Timothé Brenier || Timon
| IPv4 sur CV : 10.0.69.104, pas d'IPv4 sur SE5, IPv6 sur SE5 : 2001:660:4401:60b0:216:3eff:fedc:7539, pas de connexion à Internet en IPv4, connexion à Internet en IPv6 possible, pas de résolution DNS fonctionnelle
|-
| Florian Vallée & Maxime BALBASTRE || mushu
| IPv4 sur CV : 10.0.69.160, pas d'IPv4 sur SE5, IPv6 sur SE5 : 2001:660:4401:60b0:216:3eff:fe20:8816, pas de connexion à Internet en IPv4, connexion à Internet en IPv6 possible, pas de résolution DNS fonctionnelle
|-
| Haitam Blgrim & Black Baptiste || BlancheNeige
| IPv4 sur CV : 10.0.69.182, pas d'IPv4 sur SE5, IPv6 sur SE5 : 2001:660:4401:60b0:216:3eff:feba:38f4, pas de connexion à Internet en IPv4, connexion à Internet en IPv6 possible, pas de résolution DNS fonctionnelle
|-
| Jeanne Delcourt & Estelle Godard || cruella
| IPv4 sur CV : 10.0.69.108, pas d'IPv4 sur SE5, IPv6 sur SE5 : 2001:660:4401:60b0:216:3eff:fee5:ff99, pas de connexion à Internet en IPv4, connexion à Internet en IPv6 possible, pas de résolution DNS fonctionnelle
|-
| Jason DELANNOY & Albin MOUTON || Jafar
| IPv4 sur CV : 10.0.69.171, pas d'IPv4 sur SE5, IPv6 sur SE5 : 2001:660:4401:60b0:216:3eff:fe3e:f0bb, pas de connexion à Internet en IPv4, connexion à Internet en IPv6 possible, pas de résolution DNS fonctionnelle
|-
| Chloé Lemaire & Gabriel THOMAS || bouh
| IPv4 sur CV : 192.168.18.1, IPv4 sur SE5 : 193.48.57.180, IPv6 sur SE5 : 2001:660:4401:60b0:216:3eff:fe4f:dde2, connexion à Internet en IPv4 possible, connexion à Internet en IPv6 possible, résolution DNS fonctionnelle
|-
| Konstantin Patrikeev & Julien Charleux || judy
| IPv4 sur CV : 10.0.69.216, pas d'IPv4 sur SE5, IPv6 sur SE5 : 2001:660:4401:60b0:216:3eff:fe7d:4762, pas de connexion à Internet en IPv4, connexion à Internet en IPv6 possible, pas de résolution DNS fonctionnelle
|-
| François NAUDOT & Karl HABRE ||
|-
|}

=== Contrôle du 11/01/2024 ===

Il est normal de ne pas avoir d'adresse IPv4 sur la machine de services pour l'interface sur le commutateur virtuel. Par contre, avec mise en place de la mascarade sur la machine mandataire, il doit être possible, pour la machine de services, de se connecter à Internet en IPv4.

{| class="wikitable"
! Elève !! Nom machine !! Interfaces dans SE5 et CV !! Domaine Internet !! Accès <code>ssh</code> root !! DNS installé
|-
| Elom || Elias SIMON
| SE5 uniquement || <code>elom.lol</code>
| Non || Non
|-
| Mustafar|| Mathis RIFFAUT
| SE5 uniquement || <code>mustafare.lol</code>
| Non || Non
|-
| Dagobah|| Dann RODENBURG
| SE5 uniquement || <code>dagobah.lol</code>
| Non || Non
|-
| Motis || Mohammed Halaoui
| SE5 uniquement || <code>motis.hair</code>
| Non || Non
|-
| bogano || Benjamin Nguyen
| SE5 uniquement || <code>bogano.lol</code>
| Non || Non
|-
| Takobo || Timothé Brenier
| SE5 uniquement || <code>takobo.lol</code>
| Non || Non
|-
| Fondor || Florian Vallée
| SE5 uniquement || <code>fondor.lol</code>
| Non || Non
|-
| hoth || Haitam Blgrim
| SE5 uniquement || <code>hoth.lol</code>
| Non || Non
|-
| Abafar || Amine SELLALI
| SE5 uniquement || <code>abafar.lol</code>
| Non || Non
|-
| Rotia || Rémi Farault
| SE5 uniquement || Aucun
| Ajouté || Non
|-
| jedha || Julien Charleux
| SE5 uniquement || Aucun
| Non || Non
|-
| Bogden || Black Baptiste
| SE5 uniquement || <code>bodgen.lol</code>
| Non || Non
|-
| jiruus || Jeanne Delcourt
| SE5 uniquement || <code>jiruus.lol</code>
| Ajouté || Non
|-
| exegol || Estelle Godard
| SE5 uniquement || <code>exegol.lol</code>
| Ajouté || Non
|-
| Jakku || Jason DELANNOY
| SE5 uniquement || <code>jakku.lol</code>
| Ajouté || Non
|-
| naboo || Chloé Lemaire
| SE5 uniquement || <code>naboo.lol</code>
| Ajouté || Non
|-
| geonosis || Gabriel THOMAS
| SE5 uniquement || <code>geonosis.lol</code>
| Ajouté || Non
|-
| alderaan || Albin MOUTON
| SE5 uniquement || <code>alderaan.website</code>
| Ajouté || Non
|-
| kesh || Konstantin Patrikeev
| SE5 uniquement || <code>kesh.lol</code>
| Non || Non
|-
| kashyyyk || Maxime BALBASTRE
| SE5 uniquement || <code>kashyyyk.lol</code>
| Non || Non
|-
| Felucia || François NAUDOT
| SE5 uniquement || <code>felucia.lol</code>
| Non || Non
|-
| pelagon || Paul AMOROS
| activée le 11/01/2024 (IPv6 <code>2001:660:4401:60b0:216:3eff:fe03:2af3</code>) || <code>pelagon.lol</code>
| Non || Non
|-
| Kalee || Karl HABRE
| pas de machine virtuelle || <code>kalee.lol</code>
| Non || Non
|-
|}

Machines mandataires.

{| class="wikitable"
! Elèves !! Nom machine !! Commutateur virtuel !! Interfaces dans SE5 et CV !! Accès <code>ssh</code> root !! DNS installé
|-
| Elias SIMON & Mathis RIFFAUT || Baloo
| Non || Non
| Non || Non
|-
| Dann RODENBURG & Amine SELLALI || Aladin
| Non || Non
| Non || Non
|-
| Mohammed Halaoui & Rémi Farault || Dingo
| Non || Non
| Non || Non
|-
| Benjamin Nguyen & Timothé Brenier || Timon
| Non || Non
| Non || Non
|-
| Florian Vallée & Maxime BALBASTRE || mushu
| Non || Non
| Non || Non
|-
| Haitam Blgrim & Black Baptiste || BlancheNeige
| Non || Non
| Non || Non
|-
| Jeanne Delcourt & Estelle Godard || cruella
| Non || Non
| Ajouté || Non
|-
| Jason DELANNOY & Albin MOUTON || Jafar
| Non || Non
| Ajouté || Non
|-
| Chloé Lemaire & Gabriel THOMAS || bouh
| Oui || Oui
| Ajouté || Non
|-
| Konstantin Patrikeev & Julien Charleux || judy
| Non || Non
| Non || Non
|-
| François NAUDOT & Karl HABRE || Ursula
| ||
| ||
|-
| Paul AMOROS || mandataire inconnu
| ||
| ||
|-
|}

=== Contrôle du 14/01/2024 ===

Il est normal, pour les machines de services, de ne pas avoir d'@IPv4 sur le commutateur virtuel.

{| class="wikitable"
! Elève !! Nom machine !! Configuration IP
|-
| Elom || Elias SIMON
| pas d'IPv4 sur le CV, pas d'IPv4 sur SE5, IPv6 sur SE5 : 2001:660:4401:60b0:216:3eff:fe0f:b26d, pas de connexion à Internet en IPv4, connexion à Internet en IPv6 possible, pas de résolution DNS fonctionnelle, pas de serveur DNS.
|-
| Mustafar|| Mathis RIFFAUT
| pas d'IPv4 sur le CV, pas d'IPv4 sur SE5, IPv6 sur SE5 : 2001:660:4401:60b0:216:3eff:fea9:f79, pas de connexion à Internet en IPv4, connexion à Internet en IPv6 possible, pas de résolution DNS fonctionnelle, pas de serveur DNS.
|-
| Dagobah|| Dann RODENBURG
| pas d'IPv4 sur le CV, pas d'IPv4 sur SE5, IPv6 sur SE5 : 2001:660:4401:60b0:216:3eff:fe53:7d33, pas de connexion à Internet en IPv4, connexion à Internet en IPv6 possible, pas de résolution DNS fonctionnelle, pas de serveur DNS.
|-
| Motis || Mohammed Halaoui
| pas d'IPv4 sur le CV, pas d'IPv4 sur SE5, IPv6 sur SE5 : 2001:660:4401:60b0:216:3eff:fe7c:2d6a, pas de connexion à Internet en IPv4, connexion à Internet en IPv6 possible, pas de résolution DNS fonctionnelle, pas de serveur DNS.
|-
| bogano || Benjamin Nguyen
| pas d'IPv4 sur le CV, pas d'IPv4 sur SE5, IPv6 sur SE5 : 2001:660:4401:60b0:216:3eff:fe62:6960, pas de connexion à Internet en IPv4, connexion à Internet en IPv6 possible, pas de résolution DNS fonctionnelle, pas de serveur DNS.
|-
| Takobo || Timothé Brenier
| pas d'IPv4 sur le CV, pas d'IPv4 sur SE5, IPv6 sur SE5 : 2001:660:4401:60b0:216:3eff:fe93:8c48, pas de connexion à Internet en IPv4, connexion à Internet en IPv6 possible, pas de résolution DNS fonctionnelle, pas de serveur DNS.
|-
| Fondor || Florian Vallée
| pas d'IPv4 sur le CV, pas d'IPv4 sur SE5, IPv6 sur SE5 : 2001:660:4401:60b0:216:3eff:fe2d:82bf, pas de connexion à Internet en IPv4, connexion à Internet en IPv6 possible, pas de résolution DNS fonctionnelle, pas de serveur DNS.
|-
| hoth || Haitam Blgrim
| IPv4 sur CV : 10.0.69.157, pas d'IPv4 sur SE5, IPv6 sur SE5 : 2001:660:4401:60b0:216:3eff:fee8:4736, connexion à Internet en IPv4 possible, connexion à Internet en IPv6 possible, résolution DNS fonctionnelle, <code>bind9</code> installé pas plus.
|-
| Abafar || Amine SELLALI
| pas d'IPv4 sur le CV, pas d'IPv4 sur SE5, IPv6 sur SE5 : 2001:660:4401:60b0:216:3eff:feae:bcbb, pas de connexion à Internet en IPv4, connexion à Internet en IPv6 possible, pas de résolution DNS fonctionnelle, pas de serveur DNS.
|-
| Rotia || Rémi Farault
| IPv4 sur CV : 10.0.69.130, pas d'IPv4 sur SE5, IPv6 sur SE5 : 2001:660:4401:60b0:216:3eff:fe2e:ec48, pas de connexion à Internet en IPv4, connexion à Internet en IPv6 possible, pas de résolution DNS fonctionnelle, pas de serveur DNS.
|-
| jedha || Julien Charleux
| pas d'IPv4 sur le CV, pas d'IPv4 sur SE5, IPv6 sur SE5 : 2001:660:4401:60b0:216:3eff:fef6:364f, pas de connexion à Internet en IPv4, connexion à Internet en IPv6 possible, pas de résolution DNS fonctionnelle, pas de serveur DNS.
|-
| Bogden || Black Baptiste
| IPv4 sur CV : 10.0.69.246, pas d'IPv4 sur SE5, IPv6 sur SE5 : 2001:660:4401:60b0:216:3eff:fe67:89fd, connexion à Internet en IPv4 possible, connexion à Internet en IPv6 possible, résolution DNS fonctionnelle, pas de serveur DNS.
|-
| jiruus || Jeanne Delcourt
| IPv4 sur CV : 192.168.19.3, pas d'IPv4 sur SE5, IPv6 sur SE5 : 2001:660:4401:60b0:216:3eff:fe9c:6f0e, connexion à Internet en IPv4 possible, connexion à Internet en IPv6 possible, résolution DNS fonctionnelle, serveur DNS fonctionnel.
|-
| exegol || Estelle Godard
| IPv4 sur CV : 192.168.19.2, pas d'IPv4 sur SE5, IPv6 sur SE5 : 2001:660:4401:60b0:216:3eff:fe17:bc38, connexion à Internet en IPv4 possible, connexion à Internet en IPv6 possible, résolution DNS fonctionnelle, serveur DNS fonctionnel.
|-
| Jakku || Jason DELANNOY
| IPv4 sur CV : 10.0.69.136, pas d'IPv4 sur SE5, IPv6 sur SE5 : 2001:660:4401:60b0:216:3eff:fee1:1e4d, pas de connexion à Internet en IPv4, connexion à Internet en IPv6 possible, résolution DNS fonctionnelle, serveur DNS fonctionnel.
|-
| naboo || Chloé Lemaire
| IPv4 sur CV : 192.168.18.2, pas d'IPv4 sur SE5, IPv6 sur SE5 : 2001:660:4401:60b0:216:3eff:fef2:7e2, connexion à Internet en IPv4 possible, connexion à Internet en IPv6 possible, résolution DNS fonctionnelle, serveur DNS fonctionnel.
|-
| geonosis || Gabriel THOMAS
| IPv4 sur CV : 192.168.18.3, pas d'IPv4 sur SE5, IPv6 sur SE5 : 2001:660:4401:60b0:216:3eff:feb0:b140, connexion à Internet en IPv4 possible, connexion à Internet en IPv6 possible, pas de résolution DNS fonctionnelle, serveur DNS fonctionnel (aide massive).
|-
| alderaan || Albin MOUTON
| pas d'IPv4 sur le CV, pas d'IPv4 sur SE5, IPv6 sur SE5 : 2001:660:4401:60b0:216:3eff:fe97:2114, pas de connexion à Internet en IPv4, connexion à Internet en IPv6 possible, pas de résolution DNS fonctionnelle, pas de serveur DNS.
|-
| kesh || Konstantin Patrikeev
| pas d'IPv4 sur le CV, pas d'IPv4 sur SE5, IPv6 sur SE5 : 2001:660:4401:60b0:216:3eff:fe10:e2cb, pas de connexion à Internet en IPv4, connexion à Internet en IPv6 possible, pas de résolution DNS fonctionnelle, pas de serveur DNS.
|-
| kashyyyk || Maxime BALBASTRE
| pas d'IPv4 sur le CV, pas d'IPv4 sur SE5, IPv6 sur SE5 : 2001:660:4401:60b0:216:3eff:feca:73e7, pas de connexion à Internet en IPv4, connexion à Internet en IPv6 possible, pas de résolution DNS fonctionnelle, pas de serveur DNS.
|-
| Felucia || François NAUDOT
| pas d'IPv4 sur le CV, pas d'IPv4 sur SE5, IPv6 sur SE5 : 2001:660:4401:60b0:216:3eff:fe89:460a, pas de connexion à Internet en IPv4, connexion à Internet en IPv6 possible, pas de résolution DNS fonctionnelle, pas de serveur DNS.
|-
| pelagon || Paul Amoros
| pas d'IPv4 sur le CV, pas d'IPv4 sur SE5, IPv6 sur SE5 : 2001:660:4401:60b0:216:3eff:fe03:2af3, pas de connexion à Internet en IPv4, connexion à Internet en IPv6 possible, pas de résolution DNS fonctionnelle, pas de serveur DNS.
|-
| endor || Maël Delaby
| pas d'IPv4 sur le CV, pas d'IPv4 sur SE5, IPv6 sur SE5 : 2001:660:4401:60b0:216:3eff:fe5f:ebac, connexion à Internet en IPv4 possible, connexion à Internet en IPv6 possible, résolution DNS fonctionnelle, serveur DNS fonctionnel (mauvais domaine).
|-
| Kalee || Karl Harbre
| pas d'IPv4 sur le CV, pas d'IPv4 sur SE5, IPv6 sur SE5 : 2001:660:4401:60b0:216:3eff:fe45:42ed, pas de connexion à Internet en IPv4, connexion à Internet en IPv6 possible, pas de résolution DNS fonctionnelle, pas de serveur DNS.
|}

Machines mandataires.

{| class="wikitable"
! Elèves !! Nom machine !! Configuration IP
|-
| Elias SIMON & Mathis RIFFAUT || Baloo
| pas d'IPv4 sur le CV, pas d'IPv4 sur SE5, IPv6 sur SE5 : 2001:660:4401:60b0:216:3eff:fec8:5379, pas de connexion à Internet en IPv4, connexion à Internet en IPv6 possible, pas de résolution DNS fonctionnelle, pas de serveur DNS.
|-
| Dann RODENBURG & Amine SELLALI || Aladin
| pas d'IPv4 sur le CV, pas d'IPv4 sur SE5, IPv6 sur SE5 : 2001:660:4401:60b0:216:3eff:fe6b:c000, pas de connexion à Internet en IPv4, connexion à Internet en IPv6 possible, pas de résolution DNS fonctionnelle, pas de serveur DNS.
|-
| Mohammed Halaoui & Rémi Farault || Dingo
| IPv4 sur CV : 193.48.57.181 10.0.69.156, IPv4 sur SE5 : 193.48.57.181, IPv6 sur SE5 : 2001:660:4401:60b0:216:3eff:fe0d:4f9c, pas de connexion à Internet en IPv4, connexion à Internet en IPv6 possible, pas de résolution DNS fonctionnelle, pas de serveur DNS.
|-
| Benjamin Nguyen & Timothé Brenier || Timon
| pas d'IPv4 sur le CV, pas d'IPv4 sur SE5, IPv6 sur SE5 : 2001:660:4401:60b0:216:3eff:fedc:7539, pas de connexion à Internet en IPv4, connexion à Internet en IPv6 possible, pas de résolution DNS fonctionnelle, pas de serveur DNS.
|-
| Florian Vallée & Maxime BALBASTRE || mushu
| pas d'IPv4 sur le CV, pas d'IPv4 sur SE5, IPv6 sur SE5 : 2001:660:4401:60b0:216:3eff:fe20:8816, pas de connexion à Internet en IPv4, connexion à Internet en IPv6 possible, pas de résolution DNS fonctionnelle, pas de serveur DNS.pas de serveur DNS.z
|-
| Haitam Blgrim & Black Baptiste || BlancheNeige
| IPv4 sur CV : 193.48.57.187 10.0.69.182, IPv4 sur SE5 : 193.48.57.187, IPv6 sur SE5 : 2001:660:4401:60b0:216:3eff:feba:38f4, connexion à Internet en IPv4 possible, connexion à Internet en IPv6 possible, résolution DNS fonctionnelle, <code>bind9</code> installé sans plus.
|-
| Jeanne Delcourt & Estelle Godard || cruella
| IPv4 sur CV : 193.48.57.186 192.168.19.1, IPv4 sur SE5 : 193.48.57.186, IPv6 sur SE5 : 2001:660:4401:60b0:216:3eff:fee5:ff99, connexion à Internet en IPv4 possible, connexion à Internet en IPv6 possible, résolution DNS fonctionnelle, serveur DNS secondaire configuré.
|-
| Jason DELANNOY & Albin MOUTON || Jafar
| IPv4 sur CV : 193.48.57.183 10.0.69.1, IPv4 sur SE5 : 193.48.57.183, IPv6 sur SE5 : 2001:660:4401:60b0:216:3eff:fe3e:f0bb, connexion à Internet en IPv4 possible, connexion à Internet en IPv6 possible, résolution DNS fonctionnelle, <code>bind9</code> installé sans plus.
|-
| Chloé Lemaire & Gabriel THOMAS || bouh
| IPv4 sur CV : 193.48.57.180 192.168.18.1, IPv4 sur SE5 : 193.48.57.180, IPv6 sur SE5 : 2001:660:4401:60b0:216:3eff:fe4f:dde2, connexion à Internet en IPv4 possible, connexion à Internet en IPv6 possible, résolution DNS fonctionnelle, serveur DNS secondaire configuré.
|-
| Konstantin Patrikeev & Julien Charleux || judy
| IPv4 sur CV : 193.48.57.182, IPv4 sur SE5 : 193.48.57.182, IPv6 sur SE5 : 2001:660:4401:60b0:216:3eff:fe7d:4762, connexion à Internet en IPv4 possible, connexion à Internet en IPv6 possible, résolution DNS fonctionnelle, pas de serveur DNS.
|-
| Paul Amoros & Maël Delaby || mickey
| IPv4 sur CV : 193.48.57.188 10.10.10.2 10.10.10.1, IPv4 sur SE5 : 193.48.57.188, IPv6 sur SE5 : 2001:660:4401:60b0:216:3eff:fe34:13d5, connexion à Internet en IPv4 possible, connexion à Internet en IPv6 possible, résolution DNS fonctionnelle, serveur DNS secondaire configuré mais le répertoire pour les zones secondaires n'existe pas, l'écriture échoue.
|-
| François NAUDOT & Karl HABRE || Ursula
| pas d'IPv4 sur le CV, pas d'IPv4 sur SE5, IPv6 sur SE5 : 2001:660:4401:60b0:216:3eff:fe33:7f89, pas de connexion à Internet en IPv4, connexion à Internet en IPv6 possible, pas de résolution DNS fonctionnelle, pas de serveur DNS.
|-
|}

== Répartition des binômes en ASR ==

Donnez les élèves dans chaque groupe.

{| class="wikitable"
! Groupe !! Elèves
|-
| g1 || Konstantin Patrikeev & Julien Charleux
|-
| g2 || Chloé Lemaire & Gabriel Thomas
|-
| g3 || Timothé Brenier & Benjamin Nguyen
|-
| g4 || François Naudot & Dann Rodenburg
|-
| g5 || Maël Delaby & Paul Amoros
|-
| g6 || Haitam Blgrim & Baptiste Black
|-
| g7 || Jason Delannoy & Albin Mouton
|-
| g8 || Elias Simon & Mathis Riffaut
|-
| g10 || Estelle Godard & Jeanne Delcourt
|-
| g11 || Karl Habre & Amine Sellali
|-
| g12 || Mohammed Halaoui & Rémi Farault
|-
|g13
|Maxime Balbastre & Florian Vallée
|}

Le 05/11/2023, aucun commutateur virtuel correctement configuré, soit une adresse IPv4 sur le commutateur pour aucune raison, soit une configuration <code>static</code> non adaptée, pas de <code>up</code> sur le commutateur virtuel.

== Contrôle continu ==

=== Contrôle au 05/11/2023 ===

{| class="wikitable"
! Groupe !! Elèves !! Migration !! Archi. penfret !! Archi. antifer
|-
| g1 || Konstantin Patrikeev & Julien Charleux || || jcharleu, CV conf. erronée, MV interf. vlan50, pas de config. IPv4 || kpatrikee, CV conf. erronée, MV interf. vlan50, pas de config. IPv4, routeur mauvais disque dans le <code>.cfg</code>
|-
| g2 || Chloé Lemaire & Gabriel Thomas || || gthomas, CV conf. erronée, MV mdp erroné, interf. vlan50 || clemair1, CV conf. erronée, MV interf. vlan50, pas de config. IPv4, routeur lancé, une seule interface réseau, pas de config. réseau
|-
| g3 || Timothé Brenier & Benjamin Nguyen || || bnguyen1, CV conf. erronée, MV interf. vlan50, pas de config. IPv4 || tbrenier, CV conf. erronée, MV interf. vlan50, pas de config. IPv4, routeur mauvais disque dans le <code>.cfg</code>
|-
| g4 || François Naudot & Dann Rodenburg || || drodenbu, CV conf. erronée, MV interf. vlan50, pas de config. IPv4 || fnaudot, CV conf. erronée, MV interf. vlan50, pas de config. IPv4, routeur mauvais disque dans le <code>.cfg</code>
|-
| g5 || Maël Delaby & Paul Amoros || || pas de CV, pas de MV || mdelaby, CV conf. erronée, pygrub dans la MV ? pas de routeur, faut lui créer son propre <code>.cfg</code>
|-
| g6 || Haitam Blgrim & Baptiste Black || || hblgrim, CV conf. erronée, MV avec 2 interfaces, pas de MAC sur la 1ère, config. IPv4 OK || bblack, CV commenté, pas de MV (plus exactement une machine visible via <code>xen list</code> mais pas de <code>.cfg</code> dans <code>/etc/xen</code>), pas de routeur OpenWRT
|-
| g7 || Jason Delannoy & Albin Mouton || || jdelanno, CV conf. erronée, MV interf. vlan50, pas de config. IPv4 || amouton, CV conf. erronée, MV interf. vlan50, pas de config. IPv4, routeur lancé, une seule interface réseau
|-
| g8 || Elias Simon & Mathis Riffaut || || mriffaut, CV conf. erronée, MV interf. vlan50, pas de config. IPv4 || esimon, CV conf. erronée, MV interf. vlan50, pas de config. IPv4, pas de routeur
|-
| g10 || Estelle Godard & Jeanne Delcourt || || jdelcour, CV conf. erronée, MV interf. vlan50, pas de config. IPv4 || egodard, CV conf. erronée, MV interf. vlan50, pas de config. IPv4, routeur lancé, deux interfaces réseau, changez l'ordre des interfaces dans le <code>.cfg</code>
|-
| g11 || Karl Habre & Amine Sellali || || khabre, CV conf. erronée, MV non créée, MV interf. vlan50, pas de config. IPv4 || asellali, CV conf. erronée, MV interf. vlan50, pas de config. IPv4, routeur avec une définition de disque aberrante dans le <code>.cfg</code>
|-
| g12 || Mohammed Halaoui & Rémi Farault || || rfarault, CV conf. erronée, MV interf. vlan50, pas de config. IPv4 || pas de CV, MV interf. vlan50, pas de config. IPv4, pas de routeur
|}

=== Contrôle au 20/11/2023 ===

A noter qu'un sacré coup de pouce aura été nécessaire pour configurer le routeur de promotion, avec un seul élève en appui.

{| class="wikitable"
! Groupe !! Elèves !! Migration !! Archi. penfret !! Archi. antifer
|-
| g1 || Konstantin Patrikeev & Julien Charleux || || jcharleu, CV configuration toujours erronée, pas de VLAN, MV avec une seule interface (vlan50), toujours pas de configuration IPv4 correcte || kpatrikee, CV configuration toujours erronée, pas de VLAN, MV avec une seule interface réseau (dans le vlan50), pas de configuration IPv4 correcte, pour le routeur toujours une mauvaise définition de disque dans le <code>.cfg</code>
|-
| g2 || Chloé Lemaire & Gabriel Thomas || || gthomas, CV configuration toujours erronée, pas de VLAN, MV avec une seule interface (vlan50), pas de configuration IPv4 correcte || clemair1, CV configuré, VLAN configuré, MV lancée et totalement configurée en IPv4, routeur lancé et correctement configuré
|-
| g3 || Timothé Brenier & Benjamin Nguyen || || bnguyen1, CV conf. toujours erronée, pas de VLAN, MV avec une seule interface (vlan50), toujours pas de configuration IPv4 correcte || tbrenier, CV configuration toujours erronée, pas de VLAN, MV avec une seule interface réseau (dans le vlan50), pas de configuration IPv4 correcte, pour le routeur toujours une mauvaise définition de disque dans le <code>.cfg</code>, deux interfaces cependant
|-
| g4 || François Naudot & Dann Rodenburg || || drodenbu, CV conf. toujours erronée, pas de VLAN, MV avec une seule interface (vlan50), toujours pas de configuration IPv4 correcte || fnaudot, CV configuration toujours erronée, pas de VLAN, MV avec une seule interface réseau (dans le vlan50), pas de configuration IPv4 correcte, pour le routeur toujours une mauvaise définition de disque dans le <code>.cfg</code>, deux interfaces cependant
|-
| g5 || Maël Delaby & Paul Amoros || || toujours pas de CV, pas de VLAN, toujours pas de MV || mdelaby, CV configuration toujours erronée, pas de VLAN, toujours le bootloader <code>pygrub</code> dans la MV (commenté), MV avec une seule interface réseau (dans le CV), configuration DHCP OK pour l'interface (dans le CV), toujours pas de routeur : il faut lui créer son propre <code>.cfg</code>
|-
| g6 || Haitam Blgrim & Baptiste Black || || hblgrim, CV conf. toujours erronée, pas de VLAN, MV ne démarre pas à cause de l'erreur sur le CV (correction ReX sur le CV), MV avec 2 interfaces, pas de MAC sur la première interface dans le .cfg, configuration IPv4 OK dans la MV || bblack, CV configuration toujours erronée, pas de VLAN, toujours pas e <code>.cfg</code> pour la MV, un routeur OpenWRT avec la bonne définition de disque, deux interface mais sans @MAC, aucune configuration du routeur
|-
| g7 || Jason Delannoy & Albin Mouton || || jdelanno, CV conf. toujours, erronée, pas de VLAN, MV avec une seule interface (vlan50), toujours pas de configuration IPv4 correcte || amouton, CV configuration toujours erronée, pas de VLAN, MV avec une seule interface réseau (dans le vlan50), pas de configuration IPv4 correcte, routeur lancé, une seule interface réseau, pas de configuration du routeur
|-
| g8 || Elias Simon & Mathis Riffaut || || mriffaut, CV conf. toujours erronée, pas de VLAN, MV avec une seule interface (vlan50), pas de configuration IPv4 correcte || esimon, CV configuration toujours erronée, pas de VLAN, MV avec une seule interface réseau (dans le vlan50), pas de configuration IPv4 correcte, toujours pas de routeur
|-
| g10 || Estelle Godard & Jeanne Delcourt || || jdelcour, CV conf. toujours erronée, pas de VLAN, MV avec une seule interface (vlan50), pas de configuration IPv4 correcte || egodard, CV configuration toujours erronée, pas de VLAN, MV avec une seule interface réseau (dans le vlan50), pas de configuration IPv4 correcte, routeur lancé, deux interfaces réseau, pas de configuration du routeur
|-
| g11 || Karl Habre & Amine Sellali || || khabre, CV conf. toujours erronée, pas de VLAN, MV enfin créée avec une seule interface, pas de configuration IPv4 correcte || asellali, CV configuration toujours erronée, pas de VLAN, MV avec une seule interface réseau (dans le vlan50), pas de configuration IPv4 correcte, routeur avec une définition de disque aberrante dans le <code>.cfg</code>, une seule interface, pas de configuration du routeur
|-
| g12 || Mohammed Halaoui & Rémi Farault || || rfarault, CV conf. toujours erronée, pas de VLAN, MV avec une seule interface (vlan50), pas de configuration IPv4 correcte || pas de CV, MV avec une seule interface réseau (dans le vlan50), pas de configuration IPv4 correcte, toujours pas de routeur
|}

=== Contrôle au 30/11/2023 ===

{| class="wikitable"
! Groupe !! Elèves !! Archi. penfret !! Archi. antifer
|-
| g1 || Konstantin Patrikeev & Julien Charleux || jcharleu, CV configuration toujours erronée, pas de VLAN, MV avec une seule interface (vlan50), toujours pas de configuration IPv4 correcte. || kpatrikee, CV et VLAN configurés mais dites moi comment vous trouvez 1 avec la formule <code>6+N%4</code>, MV avec les bonnes interfaces, inversion dans la configuration IPv4 entre <code>enX0</code> et <code>enX1</code>, pour le routeur toujours une mauvaise définition de disque dans le <code>.cfg</code> par contre les deux interfaces demandées sont présentes.
|-
| g2 || Chloé Lemaire & Gabriel Thomas || gthomas, CV configuré, VLAN configuré, MV lancée et totalement configurée en IPv4. || clemair1, CV configuré, VLAN configuré, MV lancée et totalement configurée en IPv4, routeur lancé et correctement configuré.
|-
| g3 || Timothé Brenier & Benjamin Nguyen || bnguyen1, CV conf. toujours erronée, pas de VLAN, MV avec une seule interface (vlan50), toujours pas de configuration IPv4 correcte. || tbrenier, CV configuration toujours erronée, pas de VLAN, MV avec une seule interface réseau (dans le vlan50), pas de configuration IPv4 correcte, pour le routeur toujours une mauvaise définition de disque dans le <code>.cfg</code>, deux interfaces cependant.
|-
| g4 || François Naudot & Dann Rodenburg || drodenbu, CV conf. toujours erronée, pas de VLAN, MV avec une seule interface (vlan50), toujours pas de configuration IPv4 correcte. || fnaudot, CV configuration toujours erronée, pas de VLAN, MV avec une seule interface réseau (dans le vlan50), pas de configuration IPv4 correcte, pour le routeur toujours une mauvaise définition de disque dans le <code>.cfg</code>, deux interfaces cependant.
|-
| g5 || Maël Delaby & Paul Amoros || toujours pas de CV, pas de VLAN, toujours pas de MV. || mdelaby, CV configuration toujours erronée, pas de VLAN, toujours le bootloader <code>pygrub</code> dans la MV (commenté), MV avec un chemin des disques étranges, MV avec une seule interface réseau (dans le CV), configuration DHCP OK pour l'interface (dans le CV), toujours pas de routeur : il faut lui créer son propre <code>.cfg</code>.
|-
| g6 || Haitam Blgrim & Baptiste Black || hblgrim, il manque les directives pour démarrer et arrêter les interfaces mais sinon CV et VLAN configurés, MV lancé et configurée, il ne faut pas de <code>gateway</code> sur <code>enX1</code>, <code>enX0</code> ne trouve pas son adresse par DHCP à cause du commutateur virtuel non activé. || bblack, CV et VLAN configurés mais pas toutes les directives de démarrage et d'arrêt, toujours pas de <code>.cfg</code> pour la MV, un routeur OpenWRT avec la bonne définition de disque, deux interface mais sans @MAC, aucune configuration du routeur.
|-
| g7 || Jason Delannoy & Albin Mouton || jdelanno, CV conf. toujours, erronée, pas de VLAN, MV avec une seule interface (vlan50), toujours pas de configuration IPv4 correcte; || amouton, CV configuration toujours erronée, pas de VLAN, MV avec une seule interface réseau (dans le vlan50), pas de configuration IPv4 correcte, routeur lancé, une seule interface réseau, pas de configuration du routeur.
|-
| g8 || Elias Simon & Mathis Riffaut || mriffaut, CV conf. toujours erronée, pas de VLAN, MV avec une seule interface (vlan50), pas de configuration IPv4 correcte. || esimon, CV configuration toujours erronée, pas de VLAN, MV avec une seule interface réseau (dans le vlan50), pas de configuration IPv4 correcte, toujours pas de routeur.
|-
| g10 || Estelle Godard & Jeanne Delcourt || jdelcour, CV configuré, VLAN configuré (par contre l'utilisation de <code>ether4</code> est impossible), MV lancée et correctement configurée en IPv4, <code>enX0</code> ne trouve pas son @IPv4 à cause de l'erreur sur le VLAN. || egodard, CV configuré, VLAN configuré (par contre l'utilisation de <code>ether4</code> est impossible), MV avec deux interfaces, correctement configurée en IPv4, pas d'adresse obtenue par DHCP, problème de l'OpenWRT, routeur OpenWRT avec les bonnes interfaces, l'adresse IPv4 sur SE5 est donnée avec un mauvais masque, linterface <code>enX0</code> reçoit bien son adresse IPv4 par DHCP.
|-
| g11 || Karl Habre & Amine Sellali || khabre, CV configuration toujours erronée, pas de VLAN, MV avec une seule interface, pas de configuration IPv4 correcte || asellali, CV configuration toujours erronée, pas de VLAN, MV avec une seule interface réseau (dans le vlan50), pas de configuration IPv4 correcte, routeur avec une définition de disque aberrante dans le <code>.cfg</code>, une seule interface, pas de configuration du routeur
|-
| g12 || Mohammed Halaoui & Rémi Farault || rfarault, CV configuré, VLAN configuré mais configuration commentée (pourquoi donc ?!), MV lancée et correctement configurée en IPv4, <code>enX0</code> ne trouve pas son @IPv4 à cause de l'absence d'interface VLAN. || CV configuré, VLAN configuré, MV avec deux interfaces, correctement configurée en IPv4, un routeur avec les deux interfaces demandées, pas d'adresse IPv4 sur SE5, serveur DHCP fonctionnel.
|}

=== Contrôle au 02/12/2023 ===

{| class="wikitable"
! Groupe !! Elèves !! MV <code>penfret</code> !! MV <code>antifer</code> !! Routeur OpenWRT
|-
| g1 || Konstantin Patrikeev & Julien Charleux
| IPv4 sur CV : 10.0.69.185, IPv4 sur VLAN50 : 172.126.145.103, IPv6 sur VLAN50 : 2001:660:4401:6050:216:3eff:fe00:a98d, pas de connexion à Internet en IPv4, pas de résolution DNS fonctionnelle
| IPv4 sur CV : 10.0.69.218, IPv4 sur VLAN50 : 172.26.145.102, IPv6 sur VLAN50 : 2001:660:4401:6050:216:3eff:fe7d:bc44, pas de connexion à Internet en IPv4, pas de résolution DNS fonctionnelle
| pas d'IPv4 routée sur Internet, une IPv6 routée sur Internet, pas de connexion à Internet en IPv4
|-
| g2 || Chloé Lemaire & Gabriel Thomas
| IPv4 sur CV : 10.0.69.212, IPv4 sur VLAN50 : 172.26.145.105, IPv6 sur VLAN50 : 2001:660:4401:6050:216:3eff:fedb:2ac4, connexion à Internet en IPv4 possible, pas de résolution DNS fonctionnelle
| IPv4 sur CV : 10.0.69.145, IPv4 sur VLAN50 : 172.26.145.104, IPv6 sur VLAN50 : 2001:660:4401:6050:216:3eff:fe31:b916, connexion à Internet en IPv4 possible, resolution DNS fonctionnelle
| IPv4 sur Internet : 193.48.57.180, une IPv6 routée sur Internet, connexion à Internet en IPv4 possible
|-
| g3 || Timothé Brenier & Benjamin Nguyen
| MV non contactable sur le VLAN 50 en IPv6
| pas d'IPv4 sur le CV, IPv4 sur VLAN50 : 172.26.145.106, IPv6 sur VLAN50 : 2001:660:4401:6050:216:3eff:feaa:f292, pas de connexion à Internet en IPv4, pas de résolution DNS fonctionnelle
| routeur openWRT non fonctionnel
|-
| g4 || François Naudot & Dann Rodenburg
| MV non contactable sur le VLAN 50 en IPv6
| pas d'IPv4 sur le CV, IPv4 sur VLAN50 : 172.26.145.108, IPv6 sur VLAN50 : 2001:660:4401:6050:216:3eff:fec6:168, pas de connexion à Internet en IPv4, pas de résolution DNS fonctionnelle
| routeur openWRT non fonctionnel (si ? non, inversion des <code>vif</code>)
|-
| g5 || Maël Delaby & Paul Amoros
| MV non contactable sur le VLAN 50 en IPv6
| image disque du fichier de configuration non présente sur <code>antifer</code>
| routeur openWRT non fonctionnel
|-
| g6 || Haitam Blgrim & Baptiste Black
| MV non contactable sur le VLAN 50 en IPv6
| pas de fichier de configuration
| routeur openWRT non fonctionnel
|-
| g7 || Jason Delannoy & Albin Mouton
| MV non contactable sur le VLAN 50 en IPv6
| machine non contactable en IPv6 sur le bridgeStudents
| pas d'adresse MAC dans le fichier de configuration
|-
| g8 || Elias Simon & Mathis Riffaut
| MV non contactable sur le VLAN 50 en IPv6
| pas d'IPv4 sur le CV, IPv4 sur VLAN50 : 172.26.145.116, IPv6 sur VLAN50 : 2001:660:4401:6050:216:3eff:fe01:754c, pas de connexion à Internet en IPv4, pas de résolution DNS fonctionnelle
| routeur openWRT non fonctionnel
|-
| g10 || Estelle Godard & Jeanne Delcourt
| IPv4 sur CV : 10.0.69.165, IPv4 sur VLAN50 : 172.26.145.121, IPv6 sur VLAN50 : 2001:660:4401:6050:216:3eff:fe7e:35e1, pas de connexion à Internet en IPv4, pas de résolution DNS fonctionnelle
| IPv4 sur CV : 10.0.69.132, IPv4 sur VLAN50 : 172.26.145.120, IPv6 sur VLAN50 : 2001:660:4401:6050:216:3eff:feb4:5ea3, pas de connexion à Internet en IPv4, pas de résolution DNS fonctionnelle
| IPv4 sur Internet : 193.48.57.191, une IPv6 routée sur Internet, pas de connexion à Internet en IPv4
|-
| g11 || Karl Habre & Amine Sellali
| MV non contactable sur le VLAN 50 en IPv6
| machine non contactable en IPv6 sur le bridgeStudents
| pas d'adresse MAC dans le fichier de configuration, création du routeur impossible
|-
| g12 || Mohammed Halaoui & Rémi Farault
| pas d'IPv4 sur le CV, IPv4 sur VLAN50 : 172.26.145.125, IPv6 sur VLAN50 : 2001:660:4401:6050:216:3eff:fe54:5aee, pas de connexion à Internet en IPv4, pas de résolution DNS fonctionnelle
| pas d'IPv4 sur le CV, IPv4 sur VLAN50 : 172.26.145.124, IPv6 sur VLAN50 : 2001:660:4401:6050:216:3eff:fe9a:5186, pas de connexion à Internet en IPv4, pas de résolution DNS fonctionnelle
| pas d'IPv4 routée sur Internet, pas d'IPv6 routée sur Internet, pas de connexion à Internet en IPv4
|-
|}

=== Contrôle au 05/12/2023 ===

Pour utiliser l'interface Web LuCi des openWRT à partir d'une zabeth :
* vérifiez que vous avez bien une IPv6 routée sur IPv6 (avec <code>ip address show dev eth0</code>, l'adresse commence par <code>2001:660:4401:60b0:</code>) ;
* si vous n'en avez pas, prenez le suffixe (les derniers 8 octets de l'adresse locale, celle qui commence par <code>fe80::</code>) et créez votre adresse IPv6 routée par la commande :
ip address add dev eth0 2001:660:4401:60b0:<suffixe>/64
bien entendu vous n'aurez oublié de rajouter la route IPv6 par défaut vers le routeur de la promotion :
ip -6 route add default via 2001:660:4401:60b0:6a9e:bff:fe46:5a76
* établissez un tunnel <code>ssh</code> avec la commande :
zabethXX# ssh -L 6443:localhost:6443 root@IPv6
* connectez vous sur LuCi avec le navigateur de la zabeth pointant sur <code>https://localhost:6443</code>.

Attention l'ordre des interfaces <code>vif</code> dans le <code>.cfg</code> a une importance.

{| class="wikitable"
! Groupe !! Elèves !! MV <code>penfret</code> !! MV <code>antifer</code> !! Routeur OpenWRT
|-
| g1 || Konstantin Patrikeev & Julien Charleux
| IPv4 sur CV : 10.0.69.185, IPv4 sur VLAN50 : 172.126.145.103, IPv6 sur VLAN50 : 2001:660:4401:6050:216:3eff:fe00:a98d, pas de connexion à Internet en IPv4, pas de résolution DNS fonctionnelle
| IPv4 sur CV : 10.0.69.218, IPv4 sur VLAN50 : 172.26.145.102, IPv6 sur VLAN50 : 2001:660:4401:6050:216:3eff:fe7d:bc44, pas de connexion à Internet en IPv4, pas de résolution DNS fonctionnelle
| pas d'IPv4 routée sur Internet (puis <code>193.48.57.191</code> donc une erreur), pas d'IPv6 routée sur Internet, pas de connexion à Internet en IPv4
|-
| g2 || Chloé Lemaire & Gabriel Thomas
| IPv4 sur CV : 10.0.69.212, IPv4 sur VLAN50 : 172.26.145.105, IPv6 sur VLAN50 : 2001:660:4401:6050:216:3eff:fedb:2ac4, connexion à Internet en IPv4 possible, pas de résolution DNS fonctionnelle
| IPv4 sur CV : 10.0.69.145, IPv4 sur VLAN50 : 172.26.145.104, IPv6 sur VLAN50 : 2001:660:4401:6050:216:3eff:fe31:b916, connexion à Internet en IPv4 possible, resolution DNS fonctionnelle
| IPv4 sur Internet : 193.48.57.180, IPv6 sur Internet : 2001:660:4401:60b0:216:3eff:fe31:b916, connexion à Internet en IPv4 possible
|-
| g3 || Timothé Brenier & Benjamin Nguyen
| IPv4 sur CV : 10.0.69.130, IPv4 sur VLAN50 : 172.26.145.107, IPv6 sur VLAN50 : 2001:660:4401:6050:216:3eff:feff:4c44, connexion à Internet en IPv4 possible, résolution DNS fonctionnelle
| IPv4 sur CV : 10.0.69.167, IPv4 sur VLAN50 : 172.26.145.106, IPv6 sur VLAN50 : 2001:660:4401:6050:216:3eff:feaa:f292, connexion à Internet en IPv4 possible, pas de résolution DNS fonctionnelle
| IPv4 sur Internet : 193.48.57.184, IPv6 sur Internet : 2001:660:4401:60b0:216:3eff:feaa:f293, connexion à Internet en IPv4 possible
|-
| g4 || François Naudot & Dann Rodenburg
| IPv4 sur CV : 10.0.69.156, IPv4 sur VLAN50 : 172.26.145.109, IPv6 sur VLAN50 : 2001:660:4401:6050:216:3eff:fe46:70cd, connexion à Internet en IPv4 possible, pas de résolution DNS fonctionnelle
| IPv4 sur CV : 10.0.69.106, IPv4 sur VLAN50 : 172.26.145.108, IPv6 sur VLAN50 : 2001:660:4401:6050:216:3eff:fec6:168, connexion à Internet en IPv4 possible, pas de résolution DNS fonctionnelle
| IPv4 sur Internet : 193.48.57.185, IPv6 sur Internet : 2001:660:4401:60b0:216:3eff:fec6:169, connexion à Internet en IPv4 possible
|-
| g5 || Maël Delaby & Paul Amoros
| IPv4 sur CV : 10.0.69.189, IPv4 sur VLAN50 : 172.26.145.111, IPv6 sur VLAN50 : 2001:660:4401:6050:216:3eff:fe14:cdb5, connexion à Internet en IPv4 possible, pas de résolution DNS fonctionnelle
| IPv4 sur CV : 10.0.69.171, IPv4 sur VLAN50 : 172.26.145.110, IPv6 sur VLAN50 : 2001:660:4401:6050:216:3eff:fe5b:b2b5, connexion à Internet en IPv4 possible, resolution DNS fonctionnelle
| IPv4 sur Internet : 193.48.57.188, IPv6 sur Internet : 2001:660:4401:60b0:216:3eff:fe5b:b2b6, connexion à Internet en IPv4 possible
|-
| g6 || Haitam Blgrim & Baptiste Black
| IPv4 sur CV : 10.0.69.100, IPv4 sur VLAN50 : 172.26.145.113, IPv6 sur VLAN50 : 2001:660:4401:6050:216:3eff:fef9:2bb9, pas de connexion à Internet en IPv4, pas de résolution DNS fonctionnelle
| pas de machine virtuelle
| bloquage du serveur <code>antifer</code> par installation du routeur openWRT sous la racine, machine non contactable en IPv6 sur le SE5
|-
| g7 || Jason Delannoy & Albin Mouton
| CV non configuré, machine non contactable en IPv6 sur le VLAN50
| machine non contactable en IPv6 sur le bridgeStudent
| pas d'adresse MAC dans le <code>.cfg</code>
|-
| g8 || Elias Simon & Mathis Riffaut
| CV non configuré, machine non contactable en IPv6 sur le VLAN50
| machine non contactable en IPv6 sur le bridgeStudents
| machine non contactable en IPv6 sur le SE5
|-
| g10 || Estelle Godard & Jeanne Delcourt
| IPv4 sur CV : 10.0.69.165, IPv4 sur VLAN50 : 172.26.145.121, IPv6 sur VLAN50 : 2001:660:4401:6050:216:3eff:fe7e:35e1, pas de connexion à Internet en IPv4, pas de résolution DNS fonctionnelle
| IPv4 sur CV : 10.0.69.132, IPv4 sur VLAN50 : 172.26.145.120, IPv6 sur VLAN50 : 2001:660:4401:6050:216:3eff:feb4:5ea3, pas de connexion à Internet en IPv4, pas de résolution DNS fonctionnelle
| IPv4 sur Internet : 193.48.57.191 (erreur !!), IPv6 sur Internet : 2001:660:4401:60b0:216:3eff:feb4:5ea4, pas de connexion à Internet en IPv4
|-
| g11 || Karl Habre & Amine Sellali
| machine non contactable en IPv6 sur le VLAN50
| machine non contactable en IPv6 sur le bridgeStudents
| pas d'adresse MAC dans le <code>.cfg</code>
|-
| g12 || Mohammed Halaoui & Rémi Farault
| IPv4 sur CV : 10.0.69.131, IPv4 sur VLAN50 : 172.26.145.125, IPv6 sur VLAN50 : 2001:660:4401:6050:216:3eff:fe54:5aee, pas de connexion à Internet en IPv4, pas de résolution DNS fonctionnelle
| pas d'IPv4 sur le CV, IPv4 sur VLAN50 : 172.26.145.124, IPv6 sur VLAN50 : 2001:660:4401:6050:216:3eff:fe9a:5186, pas de connexion à Internet en IPv4, pas de résolution DNS fonctionnelle
| IPv4 sur Internet : 193.48.57.181, IPv6 sur Internet : 2001:660:4401:60b0:216:3eff:fe9a:5186, pas de connexion à Internet en IPv4
|-
|}

Pas de changement sur les routeurs OpenWRT à 17h30.

Pas de changement sur les MV d'<code>antifer</code> à 18h00.

Une seule modification sur les MV de <code>penfret</code> à 18h15 : la G7 (<code>g7jdelannoVM</code>) est maintenant contactable (@IPv4 et @IPv6 sur le VLAN50) mais sans rien de plus.

=== Contrôle au 06/12/2023 ===

Données brutes pour les routeurs openWRT (pas de relancement) :

G1 | IPv4 sur Internet : 193.48.57.191, IPv6 sur Internet : 2001:660:4401:60b0:216:3eff:fe7d:bc44, pas de connexion à Internet en IPv4
G2 | IPv4 sur Internet : 193.48.57.180, IPv6 sur Internet : 2001:660:4401:60b0:216:3eff:fe31:b916, connexion à Internet en IPv4 possible
G3 | IPv4 sur Internet : 193.48.57.184, IPv6 sur Internet : 2001:660:4401:60b0:216:3eff:feaa:f293, connexion à Internet en IPv4 possible
G4 | IPv4 sur Internet : 193.48.57.185, IPv6 sur Internet : 2001:660:4401:60b0:216:3eff:fec6:169, connexion à Internet en IPv4 possible
G5 | IPv4 sur Internet : 193.48.57.188, IPv6 sur Internet : 2001:660:4401:60b0:216:3eff:fe5b:b2b6, connexion à Internet en IPv4 possible
G6 | IPv4 sur Internet : 193.48.57.187, IPv6 sur Internet : 2001:660:4401:60b0:216:3eff:fef9:2bba, connexion à Internet en IPv4 possible
G7 | Bad MAC address
G8 | machine non contactable en IPv6 sur le SE5
G9 | Rien
G10 | IPv4 sur Internet : 193.48.57.186, IPv6 sur Internet : 2001:660:4401:60b0:216:3eff:feb4:5ea4, pas de connexion à Internet en IPv4
G11 | machine non contactable en IPv6 sur le SE5
G12 | IPv4 sur Internet : 193.48.57.181, IPv6 sur Internet : 2001:660:4401:60b0:216:3eff:fe9a:5186, pas de connexion à Internet en IPv4

Données brutes pour les MV sur <code>antifer</code> :

==== g1kpatrikeevVM
| IPv4 sur CV : 10.0.69.218, IPv4 sur VLAN50 : 172.26.145.102, IPv6 sur VLAN50 : 2001:660:4401:6050:216:3eff:fe7d:bc44, pas de connexion à Internet en IPv4, pas de résolution DNS fonctionnelle
==== g2clemair1VM
| IPv4 sur CV : 10.0.69.145, IPv4 sur VLAN50 : 172.26.145.104, IPv6 sur VLAN50 : 2001:660:4401:6050:216:3eff:fe31:b916, connexion à Internet en IPv4 possible, resolution DNS fonctionnelle
==== g3tbrenierVM
| IPv4 sur CV : 10.0.69.167, IPv4 sur VLAN50 : 172.26.145.106, IPv6 sur VLAN50 : 2001:660:4401:6050:216:3eff:feaa:f292, connexion à Internet en IPv4 possible, pas de résolution DNS fonctionnelle
==== g4fnaudotVM
| IPv4 sur CV : 10.0.69.106, IPv4 sur VLAN50 : 172.26.145.108, IPv6 sur VLAN50 : 2001:660:4401:6050:216:3eff:fec6:168, connexion à Internet en IPv4 possible, pas de résolution DNS fonctionnelle
==== g5mdelabyVM
| IPv4 sur CV : 10.0.69.171, IPv4 sur VLAN50 : 172.26.145.110, IPv6 sur VLAN50 : 2001:660:4401:6050:216:3eff:fe5b:b2b5, connexion à Internet en IPv4 possible, resolution DNS fonctionnelle
==== g6bblackVM
| IPv4 sur CV : 10.0.69.113, IPv4 sur VLAN50 : 172.26.145.112, IPv6 sur VLAN50 : 2001:660:4401:6050:216:3eff:fe4a:d2be, connexion à Internet en IPv4 possible, resolution DNS fonctionnelle
==== g7amoutonVM
| pas d'IPv4 sur le CV, IPv4 sur VLAN50 : 172.26.145.114, IPv6 sur VLAN50 : 2001:660:4401:6050:216:3eff:fe59:7616, pas de connexion à Internet en IPv4, pas de résolution DNS fonctionnelle
==== g8esimonVM
| machine non contactable en IPv6 sur le bridgeStudents
==== g10egodardVM
| IPv4 sur CV : 10.0.69.132, IPv4 sur VLAN50 : 172.26.145.120, IPv6 sur VLAN50 : 2001:660:4401:6050:216:3eff:feb4:5ea3, pas de connexion à Internet en IPv4, pas de résolution DNS fonctionnelle
==== g11asellaliVM
| machine non contactable en IPv6 sur le bridgeStudents
==== g12mhalaouiVM
| pas d'IPv4 sur le CV, IPv4 sur VLAN50 : 172.26.145.124, IPv6 sur VLAN50 : 2001:660:4401:6050:216:3eff:fe9a:5186, pas de connexion à Internet en IPv4, pas de résolution DNS fonctionnelle

Données brutes pour les MV sur <code>penfret</code> :

==== g1jcharleuxVM
| IPv4 sur CV : 10.0.69.185, IPv4 sur VLAN50 : 172.126.145.103, IPv6 sur VLAN50 : 2001:660:4401:6050:216:3eff:fe00:a98d, pas de connexion à Internet en IPv4, pas de résolution DNS fonctionnelle
==== g2gthomasVM
| IPv4 sur CV : 10.0.69.212, IPv4 sur VLAN50 : 172.26.145.105, IPv6 sur VLAN50 : 2001:660:4401:6050:216:3eff:fedb:2ac4, connexion à Internet en IPv4 possible, pas de résolution DNS fonctionnelle
==== g3bnguyen1VM
| IPv4 sur CV : 10.0.69.130, IPv4 sur VLAN50 : 172.26.145.107, IPv6 sur VLAN50 : 2001:660:4401:6050:216:3eff:feff:4c44, connexion à Internet en IPv4 possible, résolution DNS fonctionnelle
==== g4drodenbuVM
| IPv4 sur CV : 10.0.69.156, IPv4 sur VLAN50 : 172.26.145.109, IPv6 sur VLAN50 : 2001:660:4401:6050:216:3eff:fe46:70cd, connexion à Internet en IPv4 possible, pas de résolution DNS fonctionnelle
==== g5pamorosVM
| IPv4 sur CV : 10.0.69.189, IPv4 sur VLAN50 : 172.26.145.111, IPv6 sur VLAN50 : 2001:660:4401:6050:216:3eff:fe14:cdb5, connexion à Internet en IPv4 possible, pas de résolution DNS fonctionnelle
==== g6hblgrimVM
| IPv4 sur CV : 10.0.69.100, IPv4 sur VLAN50 : 172.26.145.113, IPv6 sur VLAN50 : 2001:660:4401:6050:216:3eff:fef9:2bb9, connexion à Internet en IPv4 possible, résolution DNS fonctionnelle
==== g7jdelannoVM
| pas d'IPv4 sur le CV, IPv4 sur VLAN50 : 172.26.145.115, IPv6 sur VLAN50 : 2001:660:4401:6050:216:3eff:fe0f:aba1, pas de connexion à Internet en IPv4, pas de résolution DNS fonctionnelle
==== g8mriffautVM
| machine non contactable en IPv6 sur le VLAN50
==== g10jdelcourVM
| IPv4 sur CV : 10.0.69.165, IPv4 sur VLAN50 : 172.26.145.121, IPv6 sur VLAN50 : 2001:660:4401:6050:216:3eff:fe7e:35e1, pas de connexion à Internet en IPv4, pas de résolution DNS fonctionnelle
==== g11khabreVM
| machine non contactable en IPv6 sur le VLAN50
==== g12rfaraultVM
| IPv4 sur CV : 10.0.69.131, IPv4 sur VLAN50 : 172.26.145.125, IPv6 sur VLAN50 : 2001:660:4401:6050:216:3eff:fe54:5aee, pas de connexion à Internet en IPv4, pas de résolution DNS fonctionnelle

Trois groupes finissent à 17h : G2, G5 et G7.

Un groupe à 17h20 : G6.

Un groupe à 17h40 : G10.

Le reste :

G8 -> installation du conteneur synapse
G3 -> erreur à la connexion de la base de données, encodage ASCII
G4 -> création de la base de données
G12 -> problème à l'exécution du conteneur
G11 -> essayent d'installer le conteneur synapse sur la zabeth
G13 -> installation du mandataire inverse (reverse proxy nginx)
G1 -> installation du conteneur synapse, se lance mais en échec

G13 n'a pas mis à jour le tableau de répartition.

SE5 ECEAI/eceai 2023/2024/Brenier-Nguyen

2023-12-20T14:44:31Z

Tbrenier :

SE5 ECEAI/eceai 2023/2024/Brenier-Nguyen

2023-12-20T14:19:23Z

Tbrenier :

SE5 ECEAI/eceai 2023/2024/Brenier-Nguyen

2023-12-20T08:31:51Z

Tbrenier :

SE5 ECEAI/eceai 2023/2024/Brenier-Nguyen

2023-12-19T14:52:34Z

Tbrenier :

SE5 ECEAI/eceai 2023/2024/Brenier-Nguyen

2023-12-18T16:47:36Z

Tbrenier :

SE5 ECEAI/eceai 2023/2024/Brenier-Nguyen

2023-12-18T16:46:49Z

Tbrenier :

Fichier:CaptureIndexBrenierNguyen.png

2023-12-18T16:44:21Z

Tbrenier :

Démonstration de la récupération et de l'affichage du JSON reçu par le serveur

SE5 ECEAI/eceai 2023/2024/Brenier-Nguyen

2023-12-18T16:37:05Z

Tbrenier :

SE5 ECEAI/eceai 2023/2024/Brenier-Nguyen

2023-12-18T16:35:30Z

Tbrenier :

SE5 ECEAI/eceai 2023/2024/Brenier-Nguyen

2023-12-18T16:35:05Z

Tbrenier :

SE5 ECEAI/eceai 2023/2024/Brenier-Nguyen

2023-12-18T16:34:38Z

Tbrenier :

SE5 ECEAI/eceai 2023/2024/Brenier-Nguyen

2023-12-18T16:23:52Z

Tbrenier :

SE5 ECEAI/eceai 2023/2024/Brenier-Nguyen

2023-12-18T16:21:49Z

Tbrenier :

SE5 ECEAI/eceai 2023/2024/Brenier-Nguyen

2023-12-18T16:10:30Z

Tbrenier : Page créée avec « * Séance 1 : ** Création et configuration de la VM sur Chassiron »

* Séance 1 :
** Création et configuration de la VM sur Chassiron

SE5 ECEAI 2023/2024

2023-12-18T16:09:26Z

Tbrenier :

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 ==
'''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