# 🛰️ MKII / Magnetometer MKii est un dispositif de mesure magnétique, il est constitué de 7 capteurs immergés et reliés via un cable de 300m à une application Magnetometer chargée de l'acquisiion des données. ```diagram <svg xmlns="http://www.w3.org/2000/svg" style="background: transparent; background-color: transparent; color-scheme: light dark;" xmlns:xlink="http://www.w3.org/1999/xlink" version="1.1" width="691px" height="336px" viewBox="-0.5 -0.5 691 336" content="&lt;mxfile host=&quot;embed.diagrams.net&quot; agent=&quot;Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:135.0) Gecko/20100101 Firefox/135.0&quot; version=&quot;28.1.1&quot;&gt;&lt;diagram id=&quot;vDocb-3__S3xyXYEcrIT&quot; name=&quot;Page-1&quot;&gt;7VhLb6MwEP41XCMwj5BjkzS7h65UqYftnioXHPCuwciYPPbX7ziYhwNtU22aqFIjJZkZjx/zeb4xxnIX2e6bwEX6g8eEWciOd5a7tBByPBTAn7Lsa0sYOLUhETTWTp3hgf4l2mhra0VjUhqOknMmaWEaI57nJJKGDQvBt6bbmjNz1gInZGB4iDAbWn/SWKY6CjTt7N8JTdJmZieY1S0Zbpx1JGWKY77tmdxby10IzmUtZbsFYQq8Bpe63+qF1nZhguTypA5+3WODWaWD0wuT+yZawas8JqqDbbnzbUoleShwpFq3sL9gS2XGQHNA1MMRIcnuxTU5baSQIoRnRIo9uDQdbA2Ozg7ka33bYR3MtC3t4ey62oj1/ibt2B0EIGgUxhGZDuInMWy+VrmQKU94jtltZ52bCHU+d5wXGpffRMq9zmRcSW6iRnZUPvbkX2qoia+15U6PfFD2jZJDZI99pddLqV23g9b1i28UB0DNeU5qy4oqQA7taxAXnHFxiN61bd8ma7CXUvA/xGhxlvNFu+cKptd3HFDllYi0l040iUVCtJc3nheCMCzpxhz9f/YYvSfpnbeT/giy+nMeMrSVQpPBd0bIMMaFM1Bh9kWFy1DBHVLBvxAV3M9DBS+4HhXCLypchgrekAruhajgfR4quL53NSq864nxujBNnetVjGAA02Qysdrn/g4sCE+aiGBGkxzkCMIkAMtcgUDh+nGjGzIax4cSMwatWXbOgKI/ux6KzVQ9GKfqYocLSSpRfj4wPfcITN+/HJjO29SNKrFpmds7FCKGy5JGJrYmOs1x1cgfeVxd8ZLioPEN7m2gP7KBje3kY0vPcM8prK+7HB/lj4eOEqNeve7Vv/kfDxSaAw0uz3XMg4EgIfC+51Yoh/IdCw7t19d1dOFxA8MfhHoFXca3e3AaCU64/NHs8AKon+ratKRZAjMw+gy/EaPFExZSiTwrKqgvAMTqDooTL54cFO7gOyny5Ax1Ax3BiMJhEQ5H0i48R90YXhLuoHYSCwVMVdtnAVKiJKBbduGavOa5NPhu26vVmV5EoRe4dolaPXwaveelBMztWP1IgTeYss93ACJvnN8fACqo3ZvUulR076Pd238=&lt;/diagram&gt;&lt;/mxfile&gt;"><defs/><g><g data-cell-id="0"><g data-cell-id="1"><g data-cell-id="15"><g><rect x="0" y="0" width="690" height="330" fill="#ffffff" style="fill: light-dark(#ffffff, var(--ge-dark-color, #121212)); stroke: light-dark(rgb(0, 0, 0), rgb(255, 255, 255));" stroke="#000000" pointer-events="all"/></g></g><g data-cell-id="7"><g><path d="M 180 275 L 254 275" fill="none" stroke="#001dbc" style="stroke: light-dark(rgb(0, 29, 188), rgb(178, 203, 255));" stroke-miterlimit="10" pointer-events="stroke"/></g></g><g data-cell-id="2"><g><rect x="120" y="260" width="60" height="30" rx="4.5" ry="4.5" fill="#333333" style="fill: light-dark(rgb(51, 51, 51), rgb(193, 193, 193)); stroke: light-dark(rgb(0, 0, 0), rgb(255, 255, 255));" stroke="#000000" pointer-events="all"/></g></g><g data-cell-id="9"><g><path d="M 420 275 L 610 275" fill="none" stroke="#001dbc" style="stroke: light-dark(rgb(0, 29, 188), rgb(178, 203, 255));" stroke-miterlimit="10" pointer-events="stroke"/></g></g><g data-cell-id="3"><g><rect x="360" y="260" width="60" height="30" rx="4.5" ry="4.5" fill="#333333" style="fill: light-dark(rgb(51, 51, 51), rgb(193, 193, 193)); stroke: light-dark(rgb(0, 0, 0), rgb(255, 255, 255));" stroke="#000000" pointer-events="all"/></g></g><g data-cell-id="8"><g><path d="M 314 275 L 360 275" fill="none" stroke="#001dbc" style="stroke: light-dark(rgb(0, 29, 188), rgb(178, 203, 255));" stroke-miterlimit="10" pointer-events="stroke"/></g></g><g data-cell-id="4"><g><rect x="254" y="260" width="60" height="30" rx="4.5" ry="4.5" fill="#333333" style="fill: light-dark(rgb(51, 51, 51), rgb(193, 193, 193)); stroke: light-dark(rgb(0, 0, 0), rgb(255, 255, 255));" stroke="#000000" pointer-events="all"/></g></g><g data-cell-id="5"><g><rect x="610" y="260" width="60" height="30" rx="4.5" ry="4.5" fill="#333333" style="fill: light-dark(rgb(51, 51, 51), rgb(193, 193, 193)); stroke: light-dark(rgb(0, 0, 0), rgb(255, 255, 255));" stroke="#000000" pointer-events="all"/></g></g><g data-cell-id="6"><g><rect x="490" y="260" width="60" height="30" fill="none" stroke="none" pointer-events="all"/></g><g><g><switch><foreignObject style="overflow: visible; text-align: left;" pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 58px; height: 1px; padding-top: 275px; margin-left: 491px;"><div style="box-sizing: border-box; font-size: 0; text-align: center; color: #000000; "><div style="display: inline-block; font-size: 12px; font-family: Helvetica; color: light-dark(#000000, #ffffff); line-height: 1.2; pointer-events: all; white-space: normal; word-wrap: normal; ">... </div></div></div></foreignObject><text x="520" y="279" fill="light-dark(#000000, #ffffff)" font-family="Helvetica" font-size="12px" text-anchor="middle">... </text></switch></g></g></g><g data-cell-id="10"><g><rect x="330" y="305" width="60" height="30" fill="none" stroke="none" pointer-events="all"/></g><g><g><switch><foreignObject style="overflow: visible; text-align: left;" pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 58px; height: 1px; padding-top: 320px; margin-left: 331px;"><div style="box-sizing: border-box; font-size: 0; text-align: center; color: #000000; "><div style="display: inline-block; font-size: 12px; font-family: Helvetica; color: light-dark(#000000, #ffffff); line-height: 1.2; pointer-events: all; white-space: normal; word-wrap: normal; ">7 capteurs</div></div></div></foreignObject><text x="360" y="324" fill="light-dark(#000000, #ffffff)" font-family="Helvetica" font-size="12px" text-anchor="middle">7 capteurs</text></switch></g></g></g><g data-cell-id="11"><g><path d="M 120 275 Q 30 230 25 170 Q 20 110 124.02 72.18" fill="none" stroke="#001dbc" style="stroke: light-dark(rgb(0, 29, 188), rgb(178, 203, 255));" stroke-miterlimit="10" pointer-events="stroke"/><path d="M 128.95 70.38 L 123.57 76.06 L 124.02 72.18 L 121.17 69.48 Z" fill="#001dbc" style="fill: light-dark(rgb(0, 29, 188), rgb(178, 203, 255)); stroke: light-dark(rgb(0, 29, 188), rgb(178, 203, 255));" stroke="#001dbc" stroke-miterlimit="10" pointer-events="all"/></g></g><g data-cell-id="12"><g><image x="130" y="30" width="80" height="80" xlink:href="data:image/png;base64,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"/></g></g><g data-cell-id="13"><g><rect x="20" y="170" width="60" height="30" fill="none" stroke="none" pointer-events="all"/></g><g><g><switch><foreignObject style="overflow: visible; text-align: left;" pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 58px; height: 1px; padding-top: 185px; margin-left: 21px;"><div style="box-sizing: border-box; font-size: 0; text-align: center; color: #0000FF; "><div style="display: inline-block; font-size: 12px; font-family: Helvetica; color: light-dark(#0000FF, #cdcdff); line-height: 1.2; pointer-events: all; white-space: normal; word-wrap: normal; ">Ligne<br />300m</div></div></div></foreignObject><text x="50" y="189" fill="#0000FF" font-family="Helvetica" font-size="12px" text-anchor="middle">Ligne...</text></switch></g></g></g><g data-cell-id="14"><g><rect x="140" y="110" width="60" height="30" fill="none" stroke="none" pointer-events="all"/></g><g><g><switch><foreignObject style="overflow: visible; text-align: left;" pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 58px; height: 1px; padding-top: 125px; margin-left: 141px;"><div style="box-sizing: border-box; font-size: 0; text-align: center; color: #000000; "><div style="display: inline-block; font-size: 12px; font-family: Helvetica; color: light-dark(#000000, #ffffff); line-height: 1.2; pointer-events: all; white-space: normal; word-wrap: normal; ">Poste de travail</div></div></div></foreignObject><text x="170" y="129" fill="light-dark(#000000, #ffffff)" font-family="Helvetica" font-size="12px" text-anchor="middle">Poste de t...</text></switch></g></g></g></g></g></g><switch><g requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"/><a transform="translate(0,-5)" xlink:href="https://www.drawio.com/doc/faq/svg-export-text-problems" target="_blank"><text text-anchor="middle" font-size="10px" x="50%" y="100%">Text is not SVG - cannot display</text></a></switch></svg> ``` C'est une application web moderne et responsive pour la visualisation de données de capteurs en temps réel avec des coordonnées X, Y, Z. Elle comprend : - un logiciel d'acquisition - une interface IHM - un service windows pour synchroniser l'heure avec un GPS - un simulateur Python - un utilitaire pour lister les ports COM disponibles ## 📋 Dépôt Source - Capteurs : [Sources]() - Partie IHM : [Sources](https://gitea.aipice.local/HEXA-H/Mkii-IHM) - Acquisition : [Sources](https://gitea.aipice.local/HEXA-H/Hdlc) - Service GPS : [Sources](https://gitea.aipice.local/HEXA-H/GpsTimeSvc) - Simulateur : [Sources]() - Liste COM : [Sources]() ## ✨ Fonctionnalités ### Caractéristiques principales - **Graphiques en Temps Réel** : Visualisation des données issue des capteurs en direct. - **Graphiques Intelligent** : graphiques dynamique avec capacités de zoom, survol des valeurs, ... - **Support Multi-capteurs** : affichage de 7 capteurs simultanément - **Vues Individuelles/Combinées** : Affichage de l'ensemble des capteurs ainsi que le détail pour chacun - **Contrôles d'Échelle et Décalage** : Ajustement en temps réel des valeurs d'échelle et de décalage des capteurs - **Synchronisation de l'heure**: synchronisation de l'heure sur une référence fiable (GPS) ### Simulateur Programme créé pour simuler le fonctionnement des la partie acquisition. - **Simulateur Toujours Actif** : Le programme fonctionne en continu en arrière-plan - **Contrôle d'Acquisition Instantané** : Réagit aux ordres de démarrage / arret - **Communication d'État YAML** : Mises à jour d'état en temps réel via fichier `status.yaml` - **Données** : Génère les données pour tous les capteurs configurés indépendamment de l'état activé ### Interface Utilisateur IHM - **Interface Modale** : Sélection des capteurs, intégration de fichiers et paramètres dans des popups (modal box) - **Suivit d'acquisition** : rafraichissment des graphiques uniquement en mode acquisition - **État en Temps Réel** : Affichage en direct de l'état de l'acquisition et du nombre d'échantillons - **Design Responsive** : Interface basée sur Bootstrap. ### Magnetometer - **Simulateur Continu** : Génération de données de capteurs basée sur Python avec contrôle instantané - **Lecteur CSV Magnétomètre** : Importer et relire des fichiers de données historiques - **Lancement d'Application Externe** : Démarrer des applications externes et lire leurs fichiers de données - **Entrée Temps Réel** : Prêt pour l'intégration de matériel de capteurs en direct ### Gestion de Configuration - **Sauvegardes Automatiques** : Sauvegardes de configuration horodatées. - **Mappage Dynamique des Capteurs** : Configurer les capteurs sans modifications de code ### Gestion des Données - **Fichiers CSV** : Chaque acquisition crée des fichiers de données horodatés - **Navigateur de Fichiers Historiques** : Charge et analyse les sessions de données précédentes ### Déploiement de Production - **PHP 8.2/Apache** : Serveur web professionnel avec configuration personnalisée - **Python 3.12** : pour la partie acquisition et simulateur - **Cpp** : pour certains outils anexes (synchro GPS, ...) ## 🚀 Démarrage Rapide ### Déploiement de Production (Docker) 1. **Installation** 2. **Accéder à l'Application :** - Interface Web : `http://localhost` ### Configuration de Développement 1. **Installer les Dépendances Python :** ```bash pip install -r requirements.txt ``` 2. **Démarrer le Simulateur Continu :** ```bash python3 sensor_simulator.py --rate 10 ``` 3. **Démarrer l'Application :** ```bash cd setup && ./startup.sh ``` 4. **Démarrer le Simulateur de Capteurs :** ```bash # Démarrage de base (contrôle manuel via interface web) ./start_simulator.sh # Démarrage automatique avec projet et campagne ./start_simulator.sh --project test_project --campaign demo_run ``` 5. **Contrôler l'Acquisition :** - Interface Web : Utiliser les contrôles modaux ou l'interface principale - CLI : `python3 simulator_control.py start --project monproject --campaign test` ## 🎮 Contrôle de l'acquisition / du simulateur ### Communication par Fichier d'État L'IHM et Magnetometer.exe lisent régulièrement le fichier `config/status.yaml`, la communication se fait au travers de ce fichier. ```yaml acquisition: campaign: _ commands: [] current_file: _ project: _ sample_count: 0 status: Stopped ``` ### Démarrage de l'application Magnetometer.exe modifie le champs `status:` lors de l'initialisation des capteurs. Quand les capteurs sont correctement initialisés, status prend la valeur `status: Ready` ### Lancement d'une acquisition L'IHM place dans status.yaml, les informations nécessaires : ```yaml ... commands: - type: start project: campaign: ... ``` Le programme Magnetometer.exe 'voit' cette demande et déclanche la lecture des capteurs, il vide le champs 'commands', puis met à jour les informations à transmettre à l'IHM ```yaml acquisition: campaign: commands: [] current_file: MAGNETOMETER___.csv project: sample_count: status: Running ``` ### Arret d'une acquisition L'IHM place dans status.yaml, les informations nécessaires : ```yaml ... commands: - type: stop ... ``` Le programme Magnetometer.exe 'voit' cette demande et arrete la lecture des capteurs, il vide le champs 'commands', puis met à jour les informations. ```yaml acquisition: campaign: - commands: [] current_file: - project: - sample_count: 0 status: Idle ``` ### Arret de magnetometer.exe Le programme Magnetometer.exe met à jour les informations comme suit : ```yaml acquisition: campaign: - commands: [] current_file: - project: - sample_count: 0 status: Not Running ``` ## 📁 Fichiers de Données ### Génération CSV Automatique - **Basé sur Session** : Chaque acquisition crée un nouveau fichier horodaté - **Format** : `SENSOR_YYYY-MM-DD_HH-MM-SS_projet_campagne.csv` - **Localisation** : Dossier `c:/Mkii/data/` - **En-têtes** : Timestamp, Time_s, Bx, By, Bz, Temperature, Angle_X, Angle_Y, Angle_Z ### Accès aux Données Historiques - **Navigateur de Fichiers** : Interface modale pour la sélection de fichiers historiques - **Lecture** : Lecture en temps réel des données historiques - **Importation** : Télécharger des fichiers CSV externes pour analyse ## 🏗️ Architecture ### Composants du Système Le diagramme suivant représente le principe de fonctionnement de l'application. Nous retrouvons les deux processus IHM et Magnetometer.exe qui sont deux applications autonomes. Elles échangent leurs informations au travers du fichier `c:/Mkii/config/status.yaml` ```diagram <svg xmlns="http://www.w3.org/2000/svg" style="background: transparent; background-color: transparent; color-scheme: light dark;" xmlns:xlink="http://www.w3.org/1999/xlink" version="1.1" width="651px" height="531px" viewBox="-0.5 -0.5 651 531" content="&lt;mxfile host=&quot;embed.diagrams.net&quot; agent=&quot;Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:135.0) Gecko/20100101 Firefox/135.0&quot; version=&quot;28.1.1&quot;&gt;&lt;diagram id=&quot;zcC5u4cGvNVTQmhhIJPR&quot; name=&quot;Page-1&quot;&gt;7Zldb6M6EIZ/TW4rDIEml03a7h6p1a62F3vtwABWDY6Ms0n2158xmK+YbHJ0SKuVqCIVj7/fxx7jYeats8MXSbfpq4iAz1wnOsy8x5nrkrkb4D9tOVaWRUAqQyJZZAq1hjf2G4zRMdYdi6DoFVRCcMW2fWMo8hxC1bNRKcW+XywWvN/rliZgGd5Cym3rTxap1MzCvW/tX4Elad0zCZZVTkbrwmYmRUojse+YvKeZt5ZCqOopO6yBa/FqXap6z2dym4FJyNU1Fepx/KJ8ZyZnBqaO9Wyl2OUR6ArOzFvtU6bgbUtDnbtHvmhLVcYxRfDRNAdSweHsmEgzU1wiIDJQ8ohFTAXPjMksjsAk963SgW9saUdlv65HDd2kabkVAB+MBmcEXPwXPchlPRJJI4YTXwsuZFnfW6+f8Q/zBNZiSk/Td8aRzp33tWvSHfEaW1c8bwzx3Mva4Xrf6sdwt4HL4m0qpV82jYGG70mp/7ed4iwHY4+ofP/WqOncOX7f6JZWXTJmnHdYxHHshiHaCyXFO3RyomAT+ME4WPw+lYUNhSwGoJAxoHgTlGEo88UnUplbVP75+mqBwcmpvviUsyTXqHCSgKKstAQMT6YHk5GxKOLnKPY9eSxyZc5WMpKmhPQ1JQP+JxhyPyNI6luSvtIkB6VbAnkHB/j79fX9z9M3sPQtFFW74u5IUT7Lp+xZxqn2BZUOJkfrEqaMRy/0KHZ6dNhI+F6nVqmQ7DeWpzUQzJa1ip7TK/Gma5o2JRRY5nstJDkxvdJDr+ALLVQ9GsE53RZsw2u/lVGZsHwlFC6dD3vpcZcnJ/eQOxo6uZcjoL230K5FltE8wjYfzu2avnPORcW648mNqd5SHGL1pw1V6FMhT17KYo/z1vLDTFabBFaPefnGnGJFwBZWW8FyVc7eX+EP9Vg7d/7Mx7GuMU3aNP50cYlvYzkOn7KSDeBi2INeELiBcUnTTbNUx+AeDHM/9nfmJcxj7GD73bbawSVkZ+J8S84Dt5ibca4P4Q5ovAnHLJlc9S1c9ZxcyZa4Y8Al9i6GvBBy8tUjgHeGyX+Csyb2bboAyfRumzDfFvOH+mr7fp5sp618c8bLj2Rs3/btQ9jEYGIOhwcdosZ5Qh6Zx8eQ06JgYX3K2uaOPP1baNUTRFZE++Jx15XGGTrOaqMEThX71e9gSDDTx3e9cjpBg5NLrXt6TBZiJ0MwtdxOMPukIfckomMFNVG6BJTVUMmvmfh1SO1ow4S0JXHv34ZoE7O7AVE7vjERbUnM5xf21rVIT0NY1toYEakd15iQnkdqba5rkQbOxyFdWkifGd5SAa8/Z16YbhndNZ3VV7L/9dXz5LPn0Ke7kUK7mGy/MFcQ2u/03tO/&lt;/diagram&gt;&lt;/mxfile&gt;"><defs><linearGradient x1="0%" y1="0%" x2="0%" y2="100%" id="drawio-svg-eziOXGky98pog4mLlVwc-gradient-light-dark_ffffff_var_--ge-dark-color_121212_-1-light-dark_ccffff_002525_-1-s-0"><stop offset="0%" stop-color="#ffffff" style="stop-color: light-dark(#ffffff, var(--ge-dark-color, #121212)); stop-opacity: 1;" stop-opacity="1"/><stop offset="100%" stop-color="#CCFFFF" style="stop-color: light-dark(rgb(204, 255, 255), rgb(0, 37, 37)); stop-opacity: 1;" stop-opacity="1"/></linearGradient></defs><g><g data-cell-id="0"><g data-cell-id="1"><g data-cell-id="20"><g><rect x="0" y="0" width="650" height="530" fill="#ffffff" style="fill: light-dark(#ffffff, var(--ge-dark-color, #121212)); stroke: light-dark(rgb(0, 0, 0), rgb(255, 255, 255));" stroke="#000000" pointer-events="all"/></g></g><g data-cell-id="18"><g><rect x="210" y="180" width="240" height="330" rx="36" ry="36" fill-opacity="0.5" fill="url(#drawio-svg-eziOXGky98pog4mLlVwc-gradient-light-dark_ffffff_var_--ge-dark-color_121212_-1-light-dark_ccffff_002525_-1-s-0)" style="fill: url(&quot;#drawio-svg-eziOXGky98pog4mLlVwc-gradient-light-dark_ffffff_var_--ge-dark-color_121212_-1-light-dark_ccffff_002525_-1-s-0&quot;); stroke: light-dark(rgb(0, 0, 0), rgb(255, 255, 255));" stroke="#000000" stroke-opacity="0.5" pointer-events="all"/></g></g><g data-cell-id="2"><g><path d="M 20 20 L 180 20 L 200 40 L 200 150 L 40 150 L 20 130 L 20 20 Z" fill="#fff2cc" style="fill: light-dark(rgb(255, 242, 204), rgb(40, 29, 0)); stroke: light-dark(rgb(214, 182, 86), rgb(109, 81, 0));" stroke="#d6b656" stroke-miterlimit="10" pointer-events="all"/><path d="M 20 20 L 180 20 L 200 40 L 40 40 Z" fill-opacity="0.05" fill="#000000" style="fill: light-dark(rgb(0, 0, 0), rgb(237, 237, 237));" stroke="none" pointer-events="all"/><path d="M 20 20 L 40 40 L 40 150 L 20 130 Z" fill-opacity="0.1" fill="#000000" style="fill: light-dark(rgb(0, 0, 0), rgb(237, 237, 237));" stroke="none" pointer-events="all"/><path d="M 40 150 L 40 40 L 20 20 M 40 40 L 200 40" fill="none" stroke="#d6b656" style="stroke: light-dark(rgb(214, 182, 86), rgb(109, 81, 0));" stroke-miterlimit="10" pointer-events="all"/></g></g><g data-cell-id="3"><g><path d="M 450 20 L 610 20 L 630 40 L 630 150 L 470 150 L 450 130 L 450 20 Z" fill="#fff2cc" style="fill: light-dark(rgb(255, 242, 204), rgb(40, 29, 0)); stroke: light-dark(rgb(214, 182, 86), rgb(109, 81, 0));" stroke="#d6b656" stroke-miterlimit="10" pointer-events="all"/><path d="M 450 20 L 610 20 L 630 40 L 470 40 Z" fill-opacity="0.05" fill="#000000" style="fill: light-dark(rgb(0, 0, 0), rgb(237, 237, 237));" stroke="none" pointer-events="all"/><path d="M 450 20 L 470 40 L 470 150 L 450 130 Z" fill-opacity="0.1" fill="#000000" style="fill: light-dark(rgb(0, 0, 0), rgb(237, 237, 237));" stroke="none" pointer-events="all"/><path d="M 470 150 L 470 40 L 450 20 M 470 40 L 630 40" fill="none" stroke="#d6b656" style="stroke: light-dark(rgb(214, 182, 86), rgb(109, 81, 0));" stroke-miterlimit="10" pointer-events="all"/></g></g><g data-cell-id="4"><g><rect x="80" y="80" width="60" height="30" fill="none" stroke="none" pointer-events="all"/></g><g><g><switch><foreignObject style="overflow: visible; text-align: left;" pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 58px; height: 1px; padding-top: 95px; margin-left: 81px;"><div style="box-sizing: border-box; font-size: 0; text-align: center; color: #000000; "><div style="display: inline-block; font-size: 16px; font-family: Helvetica; color: light-dark(#000000, #ffffff); line-height: 1.2; pointer-events: all; white-space: normal; word-wrap: normal; ">IHM</div></div></div></foreignObject><text x="110" y="100" fill="light-dark(#000000, #ffffff)" font-family="Helvetica" font-size="16px" text-anchor="middle">IHM</text></switch></g></g></g><g data-cell-id="5"><g><rect x="520" y="80" width="60" height="30" fill="none" stroke="none" pointer-events="all"/></g><g><g><switch><foreignObject style="overflow: visible; text-align: left;" pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 58px; height: 1px; padding-top: 95px; margin-left: 521px;"><div style="box-sizing: border-box; font-size: 0; text-align: center; color: #000000; "><div style="display: inline-block; font-size: 16px; font-family: Helvetica; color: light-dark(#000000, #ffffff); line-height: 1.2; pointer-events: all; white-space: normal; word-wrap: normal; ">Magnetometer.exe</div></div></div></foreignObject><text x="550" y="100" fill="light-dark(#000000, #ffffff)" font-family="Helvetica" font-size="16px" text-anchor="middle">Magneto...</text></switch></g></g></g><g data-cell-id="6"><g><path d="M 260 250 L 260 220 L 400 220 L 400 250" fill="#ffffff" style="fill: light-dark(#ffffff, var(--ge-dark-color, #121212)); stroke: light-dark(rgb(0, 0, 0), rgb(255, 255, 255));" stroke="#000000" stroke-miterlimit="10" pointer-events="all"/><path d="M 260 250 L 260 310 L 400 310 L 400 250" fill="none" stroke="#000000" style="stroke: light-dark(rgb(0, 0, 0), rgb(255, 255, 255));" stroke-miterlimit="10" pointer-events="none"/><path d="M 260 250 L 400 250" fill="none" stroke="#000000" style="stroke: light-dark(rgb(0, 0, 0), rgb(255, 255, 255));" stroke-miterlimit="10" pointer-events="none"/></g><g><g><switch><foreignObject style="overflow: visible; text-align: left;" pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 138px; height: 1px; padding-top: 235px; margin-left: 261px;"><div style="box-sizing: border-box; font-size: 0; text-align: center; color: #000000; "><div style="display: inline-block; font-size: 12px; font-family: Helvetica; color: light-dark(#000000, #ffffff); line-height: 1.2; pointer-events: all; white-space: normal; word-wrap: normal; ">status.yaml</div></div></div></foreignObject><text x="330" y="239" fill="light-dark(#000000, #ffffff)" font-family="Helvetica" font-size="12px" text-anchor="middle">status.yaml</text></switch></g></g><g data-cell-id="7"><g><rect x="260" y="250" width="140" height="30" fill="none" stroke="none" pointer-events="all"/></g><g><g><switch><foreignObject style="overflow: visible; text-align: left;" pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe flex-start; width: 130px; height: 1px; padding-top: 265px; margin-left: 266px;"><div style="box-sizing: border-box; font-size: 0; text-align: left; max-height: 26px; overflow: hidden; color: #000000; "><div style="display: inline-block; font-size: 12px; font-family: Helvetica; color: light-dark(#000000, #ffffff); line-height: 1.2; pointer-events: all; white-space: normal; word-wrap: normal; ">Commands:</div></div></div></foreignObject><text x="266" y="269" fill="light-dark(#000000, #ffffff)" font-family="Helvetica" font-size="12px">Commands:</text></switch></g></g></g><g data-cell-id="8"><g><rect x="260" y="280" width="140" height="30" fill="none" stroke="none" pointer-events="all"/></g><g><g><switch><foreignObject style="overflow: visible; text-align: left;" pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe flex-start; width: 130px; height: 1px; padding-top: 295px; margin-left: 266px;"><div style="box-sizing: border-box; font-size: 0; text-align: left; max-height: 26px; overflow: hidden; color: #000000; "><div style="display: inline-block; font-size: 12px; font-family: Helvetica; color: light-dark(#000000, #ffffff); line-height: 1.2; pointer-events: all; white-space: normal; word-wrap: normal; ">status: </div></div></div></foreignObject><text x="266" y="299" fill="light-dark(#000000, #ffffff)" font-family="Helvetica" font-size="12px">status: </text></switch></g></g></g></g><g data-cell-id="10"><g><path d="M 260 380 L 260 350 L 400 350 L 400 380" fill="#ffffff" style="fill: light-dark(#ffffff, var(--ge-dark-color, #121212)); stroke: light-dark(rgb(0, 0, 0), rgb(255, 255, 255));" stroke="#000000" stroke-miterlimit="10" pointer-events="all"/><path d="M 260 380 L 260 470 L 400 470 L 400 380" fill="none" stroke="#000000" style="stroke: light-dark(rgb(0, 0, 0), rgb(255, 255, 255));" stroke-miterlimit="10" pointer-events="none"/><path d="M 260 380 L 400 380" fill="none" stroke="#000000" style="stroke: light-dark(rgb(0, 0, 0), rgb(255, 255, 255));" stroke-miterlimit="10" pointer-events="none"/></g><g><g><switch><foreignObject style="overflow: visible; text-align: left;" pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 138px; height: 1px; padding-top: 365px; margin-left: 261px;"><div style="box-sizing: border-box; font-size: 0; text-align: center; color: #000000; "><div style="display: inline-block; font-size: 12px; font-family: Helvetica; color: light-dark(#000000, #ffffff); line-height: 1.2; pointer-events: all; white-space: normal; word-wrap: normal; ">config.yaml</div></div></div></foreignObject><text x="330" y="369" fill="light-dark(#000000, #ffffff)" font-family="Helvetica" font-size="12px" text-anchor="middle">config.yaml</text></switch></g></g><g data-cell-id="11"><g><rect x="260" y="380" width="140" height="30" fill="none" stroke="none" pointer-events="all"/></g><g><g><switch><foreignObject style="overflow: visible; text-align: left;" pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe flex-start; width: 130px; height: 1px; padding-top: 395px; margin-left: 266px;"><div style="box-sizing: border-box; font-size: 0; text-align: left; max-height: 26px; overflow: hidden; color: #000000; "><div style="display: inline-block; font-size: 12px; font-family: Helvetica; color: light-dark(#000000, #ffffff); line-height: 1.2; pointer-events: all; white-space: normal; word-wrap: normal; ">sensors:</div></div></div></foreignObject><text x="266" y="399" fill="light-dark(#000000, #ffffff)" font-family="Helvetica" font-size="12px">sensors:</text></switch></g></g></g><g data-cell-id="12"><g><rect x="260" y="410" width="140" height="30" fill="none" stroke="none" pointer-events="all"/></g><g><g><switch><foreignObject style="overflow: visible; text-align: left;" pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe flex-start; width: 130px; height: 1px; padding-top: 425px; margin-left: 266px;"><div style="box-sizing: border-box; font-size: 0; text-align: left; max-height: 26px; overflow: hidden; color: #000000; "><div style="display: inline-block; font-size: 12px; font-family: Helvetica; color: light-dark(#000000, #ffffff); line-height: 1.2; pointer-events: all; white-space: normal; word-wrap: normal; ">serial:</div></div></div></foreignObject><text x="266" y="429" fill="light-dark(#000000, #ffffff)" font-family="Helvetica" font-size="12px">serial:</text></switch></g></g></g><g data-cell-id="13"><g><rect x="260" y="440" width="140" height="30" fill="none" stroke="none" pointer-events="all"/></g><g><g><switch><foreignObject style="overflow: visible; text-align: left;" pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe flex-start; width: 130px; height: 1px; padding-top: 455px; margin-left: 266px;"><div style="box-sizing: border-box; font-size: 0; text-align: left; max-height: 26px; overflow: hidden; color: #000000; "><div style="display: inline-block; font-size: 12px; font-family: Helvetica; color: light-dark(#000000, #ffffff); line-height: 1.2; pointer-events: all; white-space: normal; word-wrap: normal; ">gps:</div></div></div></foreignObject><text x="266" y="459" fill="light-dark(#000000, #ffffff)" font-family="Helvetica" font-size="12px">gps:</text></switch></g></g></g></g><g data-cell-id="14"><g><path d="M 131.66 176.41 L 124.87 184.43 L 120.38 160.32 L 144.9 160.76 L 138.12 168.78 L 238.34 253.59 L 245.13 245.57 L 249.62 269.68 L 225.1 269.24 L 231.88 261.22 Z" fill="none" stroke="#000000" style="stroke: light-dark(rgb(0, 0, 0), rgb(255, 255, 255));" stroke-miterlimit="10" pointer-events="all"/></g></g><g data-cell-id="15"><g><path d="M 53.15 178.41 L 44.9 184.91 L 45.31 160.39 L 69.25 165.72 L 61 172.22 L 241.85 401.59 L 250.1 395.09 L 249.69 419.61 L 225.75 414.28 L 234 407.78 Z" fill="none" stroke="#000000" style="stroke: light-dark(rgb(0, 0, 0), rgb(255, 255, 255));" stroke-miterlimit="10" pointer-events="all"/></g></g><g data-cell-id="16"><g><path d="M 427.32 259.75 L 434.75 267.17 L 410.35 269.65 L 412.83 245.25 L 420.25 252.68 L 502.68 170.25 L 495.25 162.83 L 519.65 160.35 L 517.17 184.75 L 509.75 177.32 Z" fill="none" stroke="#000000" style="stroke: light-dark(rgb(0, 0, 0), rgb(255, 255, 255));" stroke-miterlimit="10" pointer-events="all"/></g></g><g data-cell-id="17"><g><path d="M 424.48 406.01 L 433.42 411.52 L 410.26 419.57 L 407.02 395.27 L 415.96 400.77 L 555.52 173.99 L 546.58 168.48 L 569.74 160.43 L 572.98 184.73 L 564.04 179.23 Z" fill="none" stroke="#000000" style="stroke: light-dark(rgb(0, 0, 0), rgb(255, 255, 255));" stroke-miterlimit="10" pointer-events="all"/></g></g><g data-cell-id="19"><g><rect x="300" y="180" width="60" height="30" fill="none" stroke="none" pointer-events="all"/></g><g><g><switch><foreignObject style="overflow: visible; text-align: left;" pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 58px; height: 1px; padding-top: 195px; margin-left: 301px;"><div style="box-sizing: border-box; font-size: 0; text-align: center; color: #000000; "><div style="display: inline-block; font-size: 12px; font-family: Helvetica; color: light-dark(#000000, #ffffff); line-height: 1.2; pointer-events: all; font-weight: bold; white-space: normal; word-wrap: normal; ">Fichiers</div></div></div></foreignObject><text x="330" y="199" fill="light-dark(#000000, #ffffff)" font-family="Helvetica" font-size="12px" text-anchor="middle" font-weight="bold">Fichiers</text></switch></g></g></g></g></g></g><switch><g requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"/><a transform="translate(0,-5)" xlink:href="https://www.drawio.com/doc/faq/svg-export-text-problems" target="_blank"><text text-anchor="middle" font-size="10px" x="50%" y="100%">Text is not SVG - cannot display</text></a></switch></svg> ``` ### Prérequis - La partie IHM est concue autour d'une page Web, il faut en conséquence que le port 80 soit disponible sur la machine. ### Points d'Accès - 📊 **Ecran Principal** : http://localhost - ⚙️ **Barre des tâches** : 🧲 click droit ## 📁 Structure des Fichiers ### Format de Fichier Les fichiers CSV de magnétomètre ont la structure suivante : - **Valeurs séparées par point-virgule** (`;`) - **6 capteurs maximum** (Capteur 1-6) - **Colonnes de données par capteur** : - `Horodatage` - Horodatage Unix - `Bx (nT)` - Champ magnétique axe X (nanotesla) - `By (nT)` - Champ magnétique axe Y (nanotesla) - `Bz (nT)` - Champ magnétique axe Z (nanotesla) - `P (Bar)` - Pression (bar) - `Temperature` - Température (°C) - `Angle X/Y/Z` - Angles d'orientation ## ⚙️ Configuration ### Configuration des Capteurs L'édition des capteurs peut être réalisée directement dans l'interface web : ```yaml sensors: sensor_1: id: 1 name: "Accéléromètre Avant" description: "Capteur accéléromètre panneau avant" serial: "HEXAH-024545-001" enabled: true color: x: "#FF6384" # Couleur axe X y: "#36A2EB" # Couleur axe Y z: "#4BC0C0" # Couleur axe Z default_scale: x: 1.0 y: 1.0 z: 1.0 default_offset: x: 0.0 y: 0.0 z: 0.0 units: "g" location: "Panneau Avant" ``` ### Paramètres d'Affichage ```yaml display: max_sensors_displayed: 12 # Capteurs maximum à afficher (1-12) default_time_window: 30 # secondes default_update_rate: 100 # millisecondes (10 Hz) chart_height: 300 # pixels show_legend: true show_grid: true ``` # 📊 Guide d'Utilisation ### Tableau de Bord Principal #### Sources de Données 1. **Simulation de Capteurs** : Générateur de données intégré avec modes multiples - Réaliste : Simule des données réelles d'accéléromètre - Onde Sinusoïdale : Motifs d'ondes sinusoïdales mathématiques - Aléatoire : Données aléatoires dans des plages spécifiées - Zéro : Données plates pour tests ## 🎛️ Interface Utilisateur ### Tableau de Bord Principal - **Graphiques Temps Réel** : Visualisation de données de capteurs en direct avec contrôle de streaming automatique - **Panneau de Contrôle** : Démarrer/arrêter l'acquisition de données avec réponse instantanée - **Affichage d'État** : État du simulateur en temps réel, nombre d'échantillons et état d'acquisition - **Contrôles Modaux** : Interface propre avec dialogues modaux pour fonctionnalités avancées ### Composants Interface Modale #### 📡 Modale de Sélection de Capteurs - **Liste Dynamique de Capteurs** : Choisir quels capteurs afficher - **Configuration Temps Réel** : Les changements s'appliquent immédiatement aux graphiques - **Gestion des Capteurs** : Activer/désactiver les capteurs sans rechargement de page #### 📂 Modale d'Intégration de Fichiers - **Lancement d'Application Externe** : Démarrer des applications externes avec paramètres projet/campagne - **Navigateur de Fichiers Historiques** : Parcourir et charger les sessions de données précédentes - **Téléchargement de Fichier** : Importation manuelle de fichiers CSV pour analyse - **Contrôles de Lecture** : Lecture temps réel avec contrôle de vitesse (0.5x à 5x) #### ⚙️ Modale de Paramètres de Capteurs - **Contrôles Échelle/Décalage** : Ajustement de données temps réel par axe - **Configuration de Graphique** : Options d'affichage et fenêtres temporelles - **Exportation de Données** : Exportation CSV avec gestion de session ### Contrôle d'Acquisition - **Streaming de Graphiques Intelligent** : Les graphiques se mettent automatiquement en pause quand aucune acquisition - **Réponse Instantanée** : Démarrer/arrêter l'acquisition sans délais de redémarrage de processus - **Indicateurs d'État** : Retour visuel pour l'état d'acquisition et l'état du simulateur - **Suivi de Progression** : Nombres d'échantillons temps réel et informations de fichier de données ## 🔧 Gestion de Configuration ### Système de Configuration YAML Éditer la configuration à `/config.html` ou directement dans `config/config.yaml` : ```yaml sensors: sensor_1: id: 1 name: "Magnétomètre X" description: "Magnétomètre primaire axe X" serial: "HEXAH-024545-001" enabled: true color: x: "#FF6384" y: "#36A2EB" z: "#4BC0C0" units: "nT" location: "Position Avant" ``` ### Traitement des Données - **Conversion d'Horodatage** : Horodatages Unix convertis en objets Date JavaScript - **Données de Champ Magnétique** : Valeurs Bx, By, Bz en nanotesla (nT) → Visualisation graphique - **Données Environnementales** : Température en °C, Pression en Bar - **Données d'Angle** : Angles format IEEE 754 automatiquement convertis en degrés - **Taux Temps Réel** : Lecture de données à 10Hz (configurable) - **Mises à Jour Statiques** : Température et angles se rafraîchissent toutes les 5 secondes ### Fonctionnalités d'Intégration - **Mappage Automatique de Capteurs** : Capteurs de fichier (Capteur 1-6) → Capteurs d'application (sensor_1-6) - **Respect de Configuration** : Affiche seulement les capteurs activés - **Suivi de Progression** : Barre de progression visuelle avec capacité de navigation - **Contrôle de Vitesse** : Ajuster la lecture de 0.5x à 5x vitesse - **Gestion d'Erreurs** : Rapports d'erreurs complets et récupération ## � Système de Gestion d'État L'application utilise `config/status.yaml` pour la communication en temps réel entre les composants : ```yaml app: mode: development # Mode application : development|production test_trigger: false # Indicateur de déclenchement de test acquisition: type: stop # Opération courante : start|stop current_file: null # Nom du fichier de données actif mode: realistic # Mode simulation : realistic|sine|random|step|vibration project: test_project # Nom du projet de collecte de données campaign: demo_run # Nom de la campagne de collecte de données running: false # État d'acquisition sample_count: 0 # Nombre d'échantillons collectés simulator: commands: [] # File d'attente des commandes en attente ``` ### Modes d'Application - **`production`** : Mode d'opération standard - Contrôles de test cachés dans l'interface - Optimisé pour la collecte de données - Mode par défaut pour le déploiement - **`development`** : Mode de développement amélioré - Contrôles de test visibles dans le tableau de bord - Bouton "Exécuter Tests" activé - Lien "Résultats des Tests" accessible - Fonctionnalités de débogage améliorées ### Points de Terminaison API d'État **Obtenir l'État Actuel :** ```bash GET /api.php?action=get_status ``` **Définir le Mode d'Application :** ```bash POST /api.php Content-Type: application/json { "action": "send_simulator_command", "command": { "type": "set_mode", "mode": "development" } } ``` **Déclencher les Tests (Mode Développement) :** ```bash POST /api.php Content-Type: application/json { "action": "send_simulator_command", "command": { "type": "trigger_tests", "test_trigger": true } } ``` ## �🔧 Développement ### Développement Local (sans Docker) Pour le développement avec un serveur PHP local : ```bash # Démarrer serveur de développement PHP (recommandé) php -S localhost:8080 ``` **Note :** Pour la fonctionnalité complète incluant la sauvegarde de configuration, utilisez le setup Docker au lieu du serveur PHP local. ### Développement Docker Pour le développement avec changements de code en direct : ```bash # Utiliser montages de volumes pour développement cd setup/ docker-compose down docker-compose up -d # Surveiller les logs docker-compose logs -f ``` ### Permissions de Fichiers S'assurer que le répertoire config est accessible en écriture : ```bash chmod -R 755 config/ chown -R www-data:www-data config/ # Pour Apache ``` ### Vue d'Ensemble de l'Architecture #### Composants Frontend - **index.html** : Tableau de bord principal avec graphiques temps réel - **config.html** : Interface éditeur de configuration - **Modules CSS** : Style responsive avec design moderne - **Modules JavaScript** : Architecture modulaire ES6+ #### Modules JavaScript - **sensor-chart.js** : Intégration Chart.js avec données streaming - **data-logger.js** : Exportation CSV et gestion de données - **config-manager.js** : Chargement et gestion de configuration - **php-config-manager.js** : Persistance de configuration côté serveur - **magneto-file-reader.js** : Analyse de fichiers CSV et extraction de données - **magneto-file-integration.js** : Intégration UI pour lecteur de fichiers #### Composants Backend - **api.php** : API RESTful pour gestion de configuration - **Alpine Linux** : Image de base Docker légère - **Apache + PHP 8.2** : Serveur web avec support PHP moderne - **Persistance de Volumes** : Volumes Docker pour persistance de données ## 🚀 Déploiement de Production ### Déploiement Docker (Recommandé) 1. **Configurer Environnement** : ```bash git clone cd Mkii ``` 2. **Configurer Application** : ```bash # Éditer configuration si nécessaire nano config/config.yaml ``` 3. **Déployer** : ```bash cd setup/ ./setup.sh ``` 4. **Vérifier Déploiement** : ```bash ./status.sh curl http://localhost:8080 ``` ### Déploiement Manuel Pour déploiement manuel sur stack LAMP existante : 1. **Copier Fichiers** : ```bash cp -r * /var/www/html/ ``` 2. **Définir Permissions** : ```bash chown -R www-data:www-data /var/www/html/config/ chmod -R 755 /var/www/html/config/ ``` 3. **Configurer Apache** : ```apache AllowOverride All Require all granted ``` ## 🛠️ Dépannage / Problèmes Courants #### Configuration Non Sauvegardée ```bash # Vérifier permissions fichiers ls -la config/ # Devrait montrer : drwxr-xr-x www-data www-data # Corriger permissions sudo chown -R www-data:www-data config/ sudo chmod -R 755 config/ ``` #### Graphiques Non Affichés 1. Vérifier console navigateur pour erreurs JavaScript 2. Vérifier que les bibliothèques Chart.js se chargent 3. S'assurer que la configuration des capteurs est valide 4. Vérifier que la source de données est active #### Lecteur de Fichiers Non Fonctionnel 1. Vérifier que le format de fichier CSV correspond à la structure attendue 2. Vérifier console navigateur pour erreurs d'analyse 3. S'assurer que le fichier contient les en-têtes requis : "Horodatage", "Bx (nT)", etc. 4. Essayer avec fichier de données exemple du répertoire `/data/` #### Problèmes Docker ```bash # Vérifier état conteneur cd setup/ ./status.sh # Voir logs ./logs.sh # Redémarrer conteneurs ./restart.sh # Reconstruire si nécessaire ./rebuild.sh ``` ## Optimisation des Performances #### Données Haute Fréquence - Ajuster `max_buffer_size` dans la configuration - Réduire le taux de mise à jour graphique si nécessaire - Utiliser la décimation de données pour longs enregistrements #### Performance Navigateur - Vider cache navigateur si les graphiques deviennent lents - Fermer onglets navigateur inutilisés - Utiliser navigateur moderne avec accélération matérielle #### Performance Docker ```bash # Surveiller utilisation ressources docker stats # Ajuster limites mémoire dans docker-compose.yml si nécessaire services: sensor-viz-app: mem_limit: 512m ``` ## 📝 Référence API ### API de Configuration #### GET /api.php?action=read Obtenir configuration actuelle ```json { "success": true, "config": { /* Config YAML en JSON */ } } ``` #### POST /api.php Sauvegarder configuration ```json { "action": "write", "config": { /* Nouvelle configuration */ } } ``` #### GET /api.php?action=backup Créer sauvegarde configuration ```json { "success": true, "backup_file": "config_backup_2025-07-28_14-30-15.yaml" } ``` ### Format d'Exportation de Données L'exportation CSV inclut : ```csv timestamp,sensor_id,x_raw,y_raw,z_raw,x_processed,y_processed,z_processed 2025-07-28T14:30:15.123Z,1,0.123,0.456,0.789,0.123,0.456,0.789 ``` ## 🔍 Surveillance ### Logs d'Application ```bash # Logs Docker cd setup/ ./logs.sh # Logs Apache (si déploiement manuel) tail -f /var/log/apache2/error.log tail -f /var/log/apache2/access.log ``` ### Métriques de Performance - **Taux de Données** : Affiché dans barre d'état tableau de bord - **Utilisation Mémoire** : Surveiller via outils dev navigateur - **Trafic Réseau** : Vérifier onglet réseau navigateur - **Ressources Serveur** : Utiliser `htop` ou stats Docker ## 🤝 Contribution ### Style de Code - Utiliser fonctionnalités JavaScript ES6+ - Suivre indentation cohérente (4 espaces) - Ajouter commentaires JSDoc pour fonctions - Utiliser HTML et CSS sémantiques ### Tests - Tester avec fichiers de données magnétomètre exemple - Vérifier persistance configuration - Vérifier design responsive sur appareils mobiles - Valider fonctionnalité exportation CSV ### Pull Requests 1. Fork le dépôt 2. Créer branche fonctionnalité 3. Ajouter tests pour nouvelle fonctionnalité 4. Mettre à jour documentation 5. Soumettre pull request avec description claire ## 🐳 Commandes Docker Toutes les commandes Docker doivent être exécutées depuis le répertoire `setup/` : ```bash # Naviguer vers répertoire setup cd setup/ # Démarrer application docker-compose up -d # Voir logs docker-compose logs -f # Arrêter application docker-compose down # Redémarrer services docker-compose restart # Reconstruire conteneurs docker-compose build --no-cache # Accéder shell conteneur docker-compose exec sensor-viz bash ``` ### Scripts de Gestion Le répertoire setup inclut des scripts de gestion pratiques : ```bash cd setup/ # Configuration initiale ./setup.sh # Vérifier état ./status.sh # Voir logs ./logs.sh # Redémarrer application ./restart.sh # Arrêter application ./stop.sh # Reconstruire application ./rebuild.sh ``` ## 🔒 Considérations de Sécurité ### Protection des Données - Fichiers de configuration protégés de l'accès web direct via règles Apache - En-têtes CORS correctement configurés pour points de terminaison API - Système de sauvegarde automatique empêche perte de configuration - Validation d'entrée sur tous changements de configuration - Aucune donnée sensible stockée dans localStorage navigateur ### Sécurité Téléchargement de Fichiers - Validation fichiers CSV avant traitement - Limites de taille de fichier appliquées - Pas de stockage côté serveur pour données téléchargées - Analyse côté client empêche vulnérabilités serveur ## 📈 Caractéristiques de Performance ### Performance Temps Réel - Optimisé pour mises à jour de données soutenues à 10Hz - Streaming Chart.js efficace avec mise en mémoire tampon circulaire - Décimation automatique de données pour sessions longue durée - Structures de données efficaces en mémoire ### Compatibilité Navigateur - Navigateurs modernes avec support ES6+ requis - Rendu Canvas accéléré matériellement - Support WebWorker pour traitement arrière-plan - Design responsive pour appareils mobiles ### Utilisation Ressources - Utilisation mémoire typique : 50-100MB - Utilisation CPU : <10% sur matériel moderne - Bande passante réseau : Minimale (mises à jour config seulement) - Stockage : Rétention données configurable ## 🏗️ Spécifications Techniques ### Technologies Frontend - **HTML5** : Balisage sémantique avec fonctionnalités accessibilité - **CSS3** : Mise en page Grid/Flexbox avec variables CSS - **JavaScript ES6+** : Motifs async/await modernes - **Chart.js 4.x** : Graphiques accélérés matériellement - **Plugin Streaming** : Visualisation données temps réel ### Technologies Backend - **PHP 8.2** : PHP moderne avec typage fort - **Apache 2.4** : Serveur web prêt production - **Alpine Linux** : Empreinte conteneur minimale - **Docker Compose** : Orchestration multi-conteneurs ### Formats de Données - **YAML** : Configuration lisible humainement - **CSV** : Exportation données standard industrie - **JSON** : Communication API - **IEEE 754** : Représentation angles virgule flottante ## 📋 Exigences ### Exigences Système Minimales - **CPU** : Processeur dual-core 1 GHz - **RAM** : 2GB mémoire disponible - **Stockage** : 1GB espace disque libre - **Réseau** : 100 Mbps pour mises à jour temps réel ### Exigences Navigateur - **Chrome/Chromium** : 80+ - **Firefox** : 75+ - **Safari** : 13+ - **Edge** : 80+ ### Exigences Docker - **Docker** : 20.10+ - **Docker Compose** : 2.0+ - **Ports Disponibles** : 8080 - **Volumes** : Accès système fichiers hôte ## 🎯 Cas d'Usage ### Applications de Recherche - **Études Magnétomètre** : Visualisation champ magnétique temps réel - **Analyse Accéléromètre** : Surveillance mouvement et vibration - **Surveillance Environnementale** : Suivi température et orientation - **Validation Données** : Comparaison en direct de capteurs multiples ### Applications Industrielles - **Contrôle Qualité** : Validation capteurs temps réel - **Surveillance Équipement** : Analyse vibration continue - **Calibration** : Vérification décalage et échelle capteurs - **Journalisation Données** : Enregistrement mesures automatisé ### Usage Éducatif - **Démonstrations Physique** : Visualisation données capteurs en direct - **Formation Ingénierie** : Analyse données monde réel - **Exemples Programmation** : Motifs développement web modernes - **Science des Données** : Workflows importation et analyse CSV ## 📄 Licence Ce projet est open source et disponible pour usage éducatif et commercial. ## 🙏 Remerciements ### Bibliothèques Tierces - **Chart.js** : Bibliothèque graphiques puissante avec support streaming - **js-yaml** : Analyseur YAML JavaScript pour fichiers configuration - **Alpine Linux** : Image de base Docker légère - **Serveur HTTP Apache** : Plateforme serveur web fiable ### Support Format de Données - **CSV Magnétomètre** : Support pour fichiers données magnétomètre externes - **IEEE 754** : Gestion appropriée données angles virgule flottante - **CSV Point-virgule** : Compatibilité format CSV européen ## 🤝 Contribution Les contributions sont bienvenues ! Veuillez vous concentrer sur : - Améliorations performance pour données haute fréquence - Nouveaux modes simulation et motifs de données - Support mobile amélioré et design responsive - Formats exportation données additionnels et outils analyse - Exemples intégration matériel capteurs réels - Support étendu format données magnétomètre ### Mises à Jour Majeures Récentes #### V2.0 - Architecture Simulateur Continu - **Simulateur Toujours Actif** : Processus arrière-plan élimine délais démarrage - **Contrôle Acquisition Instantané** : Démarrer/arrêter acquisition données sans surcharge processus - **Streaming Graphiques Intelligent** : Pause/reprise automatique basée sur état acquisition - **Contrôle Basé Commandes** : Contrôle professionnel via communication fichier état #### V1.5 - Interface Utilisateur/UX Professionnelle - **Interface Modale** : Interface propre et organisée avec dialogues modaux - **État Temps Réel** : Surveillance simulateur en direct et affichage nombre échantillons - **Graphiques Conscients Acquisition** : Graphiques se mettent intelligemment en pause quand pas d'acquisition - **Gestion Fichiers Améliorée** : Navigateur fichiers données complet et contrôles #### V1.0 - Fonctionnalités Core - **Lecteur Fichiers Magnétomètre** : Système importation CSV complet pour données externes - **Configuration Capteurs Dynamique** : Jusqu'à 12 capteurs avec configuration en direct - **Déploiement Docker** : Conteneurs basés Alpine avec persistance volumes - **Configuration Web** : Éditeur YAML avec système sauvegarde automatique --- ## 📞 Support & Documentation ### Liens Rapides - **Application Principale** : http://localhost:8080 - **Éditeur Configuration** : http://localhost:8080/config.html - **Documentation API** : API REST intégrée pour automatisation - **Logs Conteneur** : `cd setup && ./logs.sh` ### Problèmes Courants - **Port 8080 utilisé** : Changer port dans `setup/docker-compose.yml` - **Problèmes permissions** : S'assurer volumes Docker ont permissions correctes - **Simulateur ne répond pas** : Vérifier `config/status.yaml` pour communication - **Fichiers CSV ne se chargent pas** : Vérifier format fichier correspond structure attendue ### Conseils Performance - **Données haute fréquence** : Utiliser déploiement Docker pour meilleure performance - **Gros fichiers** : Considérer chunking fichiers pour très gros ensembles données - **Capteurs multiples** : Limiter capteurs actifs pour performance graphiques optimale - **Acquisition arrière-plan** : Simulateur continue même quand navigateur fermé --- **Construit avec** : Chart.js, JavaScript Vanilla, CSS3, HTML5, PHP 8.2, Apache, Alpine Linux, Docker **🛰️ Visualisation de Données de Capteurs en Temps Réel - Système d'Acquisition Continue Professionnel !**