diff --git a/diagrams/architecture.puml b/diagrams/architecture.puml new file mode 100644 index 0000000..0e3a29f --- /dev/null +++ b/diagrams/architecture.puml @@ -0,0 +1,56 @@ +@startuml architecture_timelapse + +' Configuration pour rendre le diagramme plus compact +skinparam padding 1 +skinparam nodesep 5 +skinparam ranksep 1 +skinparam componentMargin 1 +skinparam packagePadding 2 +skinparam defaultTextAlignment center +skinparam linetype ortho +skinparam rectangle { + borderColor transparent + stereotypeBorderColor transparent +} + +!$ICONURL = "https://raw.githubusercontent.com/tupadr3/plantuml-icon-font-sprites/v3.0.0/icons" +!include $ICONURL/common.puml +!include $ICONURL/devicons/javascript.puml +!include $ICONURL/devicons/html5.puml +!include $ICONURL/devicons/css3.puml +!include $ICONURL/devicons/nodejs.puml +!include $ICONURL/devicons/postgresql.puml + +package "Hôte Proxmox" { + package "Conteneur LXC" as lxc { + package "Frontend" as frontend { + DEV_HTML5(html, "HTML5") + DEV_CSS3(css, "CSS3") #line:transparent + DEV_JAVASCRIPT(js, "JavaScript") #line:transparent + } + + package "Backend" as backend { + DEV_NODEJS(express, "ExpressJS") #line:transparent + [FFmpeg] as ffmpeg #line:transparent + note right of ffmpeg: Image vers Vidéo + } + + database "Base de données" as db { + DEV_POSTGRESQL(pg, "PostgreSQL") #line:transparent + note right of pg: Timelapses & Données + } + + frontend --> backend : HTTP/REST + backend --> db : Requêtes + backend --> ffmpeg : Traitement + } + + storage "Réplication Ceph" as ceph { + [Stockage de données] as storage #line:transparent + note right of storage: Stockage distribué + } + + lxc --> ceph : Stockage +} + +@enduml \ No newline at end of file diff --git a/diagrams/backend/backend1.puml b/diagrams/backend/backend1.puml new file mode 100644 index 0000000..51c8eb5 --- /dev/null +++ b/diagrams/backend/backend1.puml @@ -0,0 +1,77 @@ +@startuml Modèles de données + +class Project { + +id: integer + +name: string + +description: string + +start_date: date + +status: integer + +getAllProjects() + +getProjectById(id) + +createProject(name, description, startDate, status) + +updateProject(id, updates) + +updateProjectStatus(id, status) + +deleteProject(id) + +findCurrentRenderingProject() + +findStoppingProject() +} + +class Measurement { + +id: integer + +project_id: integer + +timestamp: datetime + +path: string + +temperature: float + +humidity: float + +order_id: integer + +getAllMeasurements() + +getMeasurementById(id) + +getMeasurementByProjectAndOrderId(projectId, orderId) + +getMeasurementsByProjectId(projectId) + +createMeasurement(projectId, timestamp, path, temperature, humidity, orderId) + +updateMeasurement(id, updates) + +deleteMeasurement(id) + +getNextOrderId(projectId) +} + +class Video { + +id: integer + +project_id: integer + +measurement_ids: string + +name: string + +resolution: string + +duration: integer + +status: integer + +progress: float + +video_file: string + +started_at: datetime + +updated_at: datetime + +eta: float + +getAllVideos() + +getVideoById(id) + +getVideosByProjectId(projectId) + +createVideo(projectId, measurementIds, name, resolution, duration, status) + +updateVideo(id, updates) + +updateVideoFilePath(id, videoFile) + +updateVideoStatus(id, status) + +deleteVideo(id) + +getUnfinishedVideos() + +updateVideoProgress(id, progress, eta) +} + +class Camera { + +id: integer + +interval: integer + +maintenance: integer + +active: integer + +getCamera() + +updateCamera(id, updates) + +deleteCamera(id) + +initializeCamera() +} + +Project "1" -- "0..*" Measurement : possède > +Project "1" -- "0..*" Video : possède > +Measurement "1..*" -- "0..*" Video : utilisée dans > + +@enduml \ No newline at end of file diff --git a/diagrams/backend/backend2.puml b/diagrams/backend/backend2.puml new file mode 100644 index 0000000..821438d --- /dev/null +++ b/diagrams/backend/backend2.puml @@ -0,0 +1,62 @@ +@startuml Architecture MVC + +package "Controllers" { + [ProjectController] + [MeasurementController] + [VideoController] + [ImageController] + [CameraController] +} + +package "Models" { + [Project] + [Measurement] + [Video] + [Camera] + [DatabaseManager] +} + +package "Routes" { + [projectRoutes] + [measurementRoutes] + [videoRoutes] + [imageRoutes] + [cameraRoutes] + [index] +} + +package "Services" { + [StorageService] + [VideoService] +} + +package "Utils" { + [errorHandler] +} + +package "Database" { + [connection] +} + +package "Config" { + [config] +} + +cloud "Client" { + [Frontend] +} + +[Frontend] --> [Routes] +[Routes] --> [Controllers] +[Controllers] --> [Models] +[Controllers] --> [Services] +[Models] --> [Database] +[Services] --> [Models] +[Controllers] --> [Utils] +[Models] --> [Utils] +[Services] --> [Utils] +[Models] --> [Config] +[Services] --> [Config] +[Controllers] --> [Config] + +@enduml \ No newline at end of file diff --git a/diagrams/backend/backend3.puml b/diagrams/backend/backend3.puml new file mode 100644 index 0000000..64bf0a9 --- /dev/null +++ b/diagrams/backend/backend3.puml @@ -0,0 +1,39 @@ +@startuml Création de vidéo + +actor Client +participant "videoRoutes" as Routes +participant "VideoController" as Controller +participant "Video" as Model +participant "Measurement" as MeasurementModel +participant "VideoService" as Service +participant "FFmpeg" as FFmpeg +database Database + +Client -> Routes: POST /videos +Routes -> Controller: createVideo(req, res) +Controller -> Model: createVideo(project_id, measurement_ids, name, resolution, duration) +Model -> Database: INSERT INTO videos +Database --> Model: video data +Model --> Controller: video object + +Controller -> Controller: getMeasurementPathList(measurement_ids, project_id) +Controller -> MeasurementModel: getMeasurementByProjectAndOrderId(projectId, orderId) +MeasurementModel -> Database: SELECT * FROM measurements +Database --> MeasurementModel: measurement data +MeasurementModel --> Controller: measurement object with path + +Controller -> Service: createVideoFromImages(project_id, pathList, duration, video_id, resWidth, resHeight) +Service -> FFmpeg: spawn('ffmpeg', ffmpegArgs) +Service -> Model: updateVideo(videoId, {status: rendering, progress: 0}) +Model -> Database: UPDATE videos SET status = rendering, progress = 0 +FFmpeg --> Service: stderr progress events +Service -> Model: updateVideoProgress(videoId, progress, eta) +Model -> Database: UPDATE videos SET progress = X, eta = Y +FFmpeg --> Service: process complete +Service -> Model: updateVideo(videoId, {status: completed, progress: 100}) +Model -> Database: UPDATE videos SET status = completed, progress = 100 +Service --> Controller: videoFile path +Controller --> Routes: { message: success, id: video.id } +Routes --> Client: 200 OK - JSON Response + +@enduml \ No newline at end of file diff --git a/diagrams/backend/backend4.puml b/diagrams/backend/backend4.puml new file mode 100644 index 0000000..dce00f6 --- /dev/null +++ b/diagrams/backend/backend4.puml @@ -0,0 +1,34 @@ +@startuml Cas d'utilisation + +left to right direction +actor "Utilisateur" as User +actor "Caméra" as Camera + +rectangle "Timelapse Backend" { + usecase "Gérer les projets" as UC1 + usecase "Configurer la caméra" as UC2 + usecase "Capturer des images" as UC3 + usecase "Créer des vidéos" as UC4 + usecase "Visualiser les images" as UC5 + usecase "Visualiser les vidéos" as UC6 + usecase "Démarrer une capture" as UC7 + usecase "Arrêter une capture" as UC8 + usecase "Uploader une image et des mesures" as UC9 + + UC1 ..> UC7 : <> + UC1 ..> UC8 : <> + UC2 ..> UC7 : <> + UC2 ..> UC8 : <> + UC3 ..> UC9 : <> + UC4 ..> UC5 : <> +} + +User --> UC1 +User --> UC2 +User --> UC4 +User --> UC5 +User --> UC6 +Camera --> UC3 +Camera --> UC9 + +@enduml \ No newline at end of file diff --git a/diagrams/backend/backend5.puml b/diagrams/backend/backend5.puml new file mode 100644 index 0000000..97906d8 --- /dev/null +++ b/diagrams/backend/backend5.puml @@ -0,0 +1,41 @@ +@startuml Déploiement + +node "Client Device" { + [Web Browser] as Browser +} + +node "Docker Environment" { + node "timelapse-api" { + [Express Server] as Server + [Node.js Runtime] as Node + [FFmpeg] as FFmpeg + } + + database "timelapse-db" { + [PostgreSQL] as DB + } + + folder "Volumes" { + folder "storage/" { + [Project Images] + [Generated Videos] + } + } +} + +node "Camera Device" { + [Camera Software] as CamSoftware + [Sensors] as Sensors +} + +Browser --> Server: HTTP/REST +CamSoftware --> Server: HTTP/REST +Server --> DB: SQL Queries +Server --> FFmpeg: Process Spawn +FFmpeg --> [Project Images]: Read +FFmpeg --> [Generated Videos]: Write +Server --> [Project Images]: Read/Write +Server --> [Generated Videos]: Read +Sensors --> CamSoftware: Temperature/\nHumidity Data + +@enduml \ No newline at end of file diff --git a/diagrams/frontend/frontend1.puml b/diagrams/frontend/frontend1.puml new file mode 100644 index 0000000..5b70d9e --- /dev/null +++ b/diagrams/frontend/frontend1.puml @@ -0,0 +1,42 @@ +@startuml + +class Project { + id: number + name: string + description: string + status: number + start_date: date +} + +class Measurement { + id: number + project_id: number + order_id: number + timestamp: string + temperature: number + humidity: number +} + +class Video { + id: number + project_id: number + name: string + measurement_ids: string + resolution: string + duration: number + status: number +} + +class CameraController { + active_project_id: number + start_timelapse(id, frequency, nbimages): void + stopCamera(id): void + manualUpload(imageFile, projectId, timestamp, temperature, humidity): void +} + +Project "1" *-- "n" Measurement : contient +Project "1" *-- "n" Video : contient +Measurement "n" o-- "n" Video : utilisées dans +CameraController -- Video : génère + +@enduml \ No newline at end of file diff --git a/diagrams/frontend/frontend2.puml b/diagrams/frontend/frontend2.puml new file mode 100644 index 0000000..6b678c9 --- /dev/null +++ b/diagrams/frontend/frontend2.puml @@ -0,0 +1,19 @@ +@startuml + +start +:Créer un projet; +:Configurer la caméra; +:Prises d'images automatiques; + +fork + :Upload manuel d'images; +fork again + :Arrêt de la caméra; +end fork + +:Sélection des images; +:Générer une vidéo; +:Visualiser les données; +stop + +@enduml \ No newline at end of file diff --git a/diagrams/frontend/frontend3.puml b/diagrams/frontend/frontend3.puml new file mode 100644 index 0000000..609451c --- /dev/null +++ b/diagrams/frontend/frontend3.puml @@ -0,0 +1,20 @@ +@startuml + +actor Browser +participant Frontend +participant API +participant Camera + +Browser -> Frontend : 1. Create project +Frontend -> API : 2. POST /projects +Browser -> Frontend : 3. Configure camera +Frontend -> API : 4. POST /procedure/start +API -> Camera : 4. Start capturing +Camera --> API : 5. Capture images +Browser -> Frontend : 6. Create video request +Frontend -> API : 7. POST /videos +Browser -> Frontend : 8. Render video +Frontend -> API : 9. POST /videos/render/{id} +Frontend --> Browser : 10. Display video & metrics + +@enduml \ No newline at end of file diff --git a/diagrams/frontend/frontend4.puml b/diagrams/frontend/frontend4.puml new file mode 100644 index 0000000..83c3fce --- /dev/null +++ b/diagrams/frontend/frontend4.puml @@ -0,0 +1,28 @@ +@startuml + +left to right direction +actor "Utilisateur" as user + +rectangle "Système Timelapse" { + usecase "Gérer les projets" as UC1 + usecase "Configurer la caméra" as UC2 + usecase "Créer des vidéos" as UC3 + usecase "Visualiser les données" as UC4 + usecase "Uploader manuellement" as UC5 + usecase "Afficher métriques" as UC6 + + UC1 --> UC2 + UC2 --> UC3 + UC1 --> UC4 + UC2 --> UC5 + UC3 --> UC6 +} + +user --> UC1 +user --> UC2 +user --> UC3 +user --> UC4 +user --> UC5 +user --> UC6 + +@enduml \ No newline at end of file diff --git a/diagrams/frontend/frontend5.puml b/diagrams/frontend/frontend5.puml new file mode 100644 index 0000000..388a14c --- /dev/null +++ b/diagrams/frontend/frontend5.puml @@ -0,0 +1,29 @@ +@startuml + +node "Client Browser" { + [HTML/CSS/JS] + [JQuery] + [Chart.js] +} + +node "Backend API" { + [RESTful Services] + [Image Processing] + [Video Generation] +} + +database "Filesystem Storage" { + [Images] + [Videos] +} + +node "Camera Controller" { + [Capture Configuration] + [Sensors (temp/humid)] +} + +[HTML/CSS/JS] -- [RESTful Services] : HTTP +[RESTful Services] -- [Filesystem Storage] +[RESTful Services] -- [Camera Controller] + +@enduml \ No newline at end of file diff --git a/diagrams/global.puml b/diagrams/global.puml index fa475c5..b9455ee 100644 --- a/diagrams/global.puml +++ b/diagrams/global.puml @@ -1,4 +1,4 @@ -@startuml Architecture Globale +@startuml global ' Définition des composants node "Interfaces utilisateur" { diff --git a/diagrams/global_interspec.puml b/diagrams/global_interspec.puml new file mode 100644 index 0000000..6446654 --- /dev/null +++ b/diagrams/global_interspec.puml @@ -0,0 +1,100 @@ +@startuml +left to right direction + +skinparam component { + BackgroundColor<> #FFE4B5 + BackgroundColor<<Électronique>> #98FB98 + BackgroundColor<> #87CEEB + BorderColor #333 +} + +package "Infrastructure Globale" { + component "Caméra Raspberry Pi" <<Électronique>> as pi { + component "Module Caméra" as cam + component "Scripts Capture" as scripts + } + + component "Serveur Central" <> as server { + component "Backend (Node.js/Express)" as backend + component "FFMPEG Processing" as ffmpeg + component "Base de Données" as db + } + + component "Interface Web" <> as web { + component "Frontend (HTML/CSS/JS)" as front + component "Nginx Reverse Proxy" as nginx + } + + component "Application Android" <> as android { + component "Kotlin API" as kotlin + component "Glide Image Processing" as glide + } + + component "Système Énergétique" <<Électronique>> as energy { + component "Microcontrôleur STM32" as stm + component "Batterie LiPo" as battery + component "Panneau Solaire" as solar + } + + component "Boîtier Mécanique" <> as box { + component "Structure Étanche" as structure + component "Système Fixation" as mount + } + + component "Infrastructure Virtualisée" <> as infra { + component "Proxmox VE" as proxmox + component "VM Ubuntu" as vm + component "Docker Containers" as docker + } +} + +pi --> server : "Transfert images\n(HTTP/MQTT)" +server --> web : "API REST" +server --> android : "API REST" +energy --> pi : "Alimentation\n(Power Management)" +energy --> stm : "Contrôle énergie" +box --> pi : "Protection physique" +box --> energy : "Intégration" +infra --> server : "Hébergement" +infra --> web : "Hébergement" +cam --> scripts : "Capture RAW" +scripts --> backend : "Envoi images" +backend --> ffmpeg : "Conversion vidéo" +ffmpeg --> db : "Stockage" +stm --> battery : "Monitoring" +solar --> battery : "Recharge" +front --> nginx : "Requêtes" +nginx --> backend : "Proxy" +vm --> docker : "Orchestration" +structure --> mount : "Assemblage" + +note top of pi + **Technologies Électronique** + - Altium Designer + - STM32 CubeIDE + - Protocoles I2C/SPI +end note + +note right of server + **Stack Logicielle** + - Node.js + Express + - PostgreSQL + - FFMPEG + - CI/CD Gitea +end note + +note left of energy + **Gestion Énergie** + - PCB Custom + - Capteurs température/hygro + - Algorithme économie d'énergie +end note + +note bottom of box + **Caractéristiques Mécaniques** + - PLA résistant aux UV +- Indice IP67 +- Dissipation thermique +end note + +@enduml \ No newline at end of file diff --git a/diagrams/global_interspec_lite.puml b/diagrams/global_interspec_lite.puml new file mode 100644 index 0000000..1a9b35f --- /dev/null +++ b/diagrams/global_interspec_lite.puml @@ -0,0 +1,87 @@ +@startuml +left to right direction + +skinparam component { + BackgroundColor<> #FFE4B5 + BackgroundColor<> #98FB98 + BackgroundColor<> #87CEEB + BorderColor #333 +} + +package "Matériel" <> { + component "RPi 4B + Cam" as pi { + [Module Caméra] --> [Scripts Python] + } + + component "Système d'énergie" as energy { + [STM32] --> [Batterie LiPo] + [Panneau Solaire] --> [Gestion d'énergie] + } + + component "Boîtier Mécanique" as box { + [PLA IP67] --> [Système de Montage] + } +} + +package "Logiciel" <> { + component "Backend" as backend { + [Node.js] --> [FFMPEG] + [Express] --> [PostgreSQL] + } + + component "Frontend" as web { + [React] --> [Nginx] + } + + component "Application Mobile" as mobile { + [Kotlin] --> [Android API] + } +} + +package "Infrastructure" <> { + component "Proxmox" as proxmox { + [VM Ubuntu] --> [Docker] + } +} + +pi --> backend : "HTTP/MQTT\n(images)" +energy --> pi : "Alimentation" +box --> pi : "Protection physique" +backend --> web : "API REST" +backend --> mobile : "API REST" +proxmox --> backend : "Hébergement" +proxmox --> web : "Proxy inverse" + +note right of pi +Technologie Matérielle: +• Altium Designer +• STM32 CubeIDE +• I2C/SPI +• RDM6/CES +end note + +note bottom of backend +Stack Logicielle: +• Node.js/Express +• FFMPEG +• Auth JWT +• CI/CD Gitea +end note + +note left of proxmox +Infrastructure: +• Docker Swarm +• Let's Encrypt +• VPN/Wireguard +• Sauvegardes Automatisées +end note + +note top of box +Mécanique: +• Solidworks +• BambuLab X1 +• Analyse Thermique +• Classification IP67 +end note + +@enduml \ No newline at end of file diff --git a/diagrams/raspi/01_architecture_generale.puml b/diagrams/raspi/01_architecture_generale.puml new file mode 100644 index 0000000..94d584f --- /dev/null +++ b/diagrams/raspi/01_architecture_generale.puml @@ -0,0 +1,52 @@ +@startuml Architecture Générale du Système Timelapse + +!define ICONURL https://raw.githubusercontent.com/tupadr3/plantuml-icon-font-sprites/v2.4.0 +!include ICONURL/common.puml +!include ICONURL/devicons/python.puml +!include ICONURL/font-awesome-5/raspberry_pi.puml +!include ICONURL/font-awesome-5/cloud.puml +!include ICONURL/font-awesome-5/camera.puml +!include ICONURL/font-awesome-5/database.puml + +skinparam { + BackgroundColor white + ArrowColor #666666 + BorderColor #666666 + FontName "Arial" +} + +rectangle "Système Raspberry Pi" as raspi { + DEV_PYTHON(pyonline, "timelapse_online.py") #lightblue + DEV_PYTHON(pyoffline, "timelapse_offline.py") #lightgreen + rectangle "timelapse/" { + DEV_PYTHON(config, "config.py") #lightyellow + DEV_PYTHON(apiclient, "api_client.py") #pink + DEV_PYTHON(capture, "capture.py") #lightcyan + DEV_PYTHON(sensors, "sensors.py") #lightyellow + } + FA5_DATABASE(localdb, "CONFIG/config.json") #lightgrey + FA5_CAMERA(camera, "Caméra") #white +} + +cloud "Serveur Distant" { + rectangle "API REST" as api #pink + database "Base de données" as db #lightgrey +} + +pyonline --> config : utilise +pyoffline --> config : utilise +pyonline --> apiclient : utilise +pyonline --> capture : utilise +pyoffline --> capture : utilise +capture --> config : lit/écrit +capture --> sensors : utilise +apiclient --> api : communique +config --> localdb : lit/écrit +sensors --> camera : contrôle + +note bottom of pyonline : "Mode connecté" +note bottom of pyoffline : "Mode hors ligne" +note right of api : "Authentification\net gestion des données" +note bottom of camera : "Capture des images" + +@enduml \ No newline at end of file diff --git a/diagrams/raspi/02_flux_capture.puml b/diagrams/raspi/02_flux_capture.puml new file mode 100644 index 0000000..84b795e --- /dev/null +++ b/diagrams/raspi/02_flux_capture.puml @@ -0,0 +1,77 @@ +@startuml Flux du Processus de Capture d'Images + +skinparam { + BackgroundColor white + ArrowColor #666666 + BorderColor #666666 + FontName "Arial" +} + +start +if (Connexion internet disponible?) then (oui) + :Mode connecté (timelapse_online.py); + :Récupération du statut depuis l'API; + if (Serveur accessible?) then (oui) + :Mise à jour de la configuration locale; + if (Mode maintenance?) then (oui) + :Arrêt du processus; + stop + else (non) + if (Demande d'arrêt?) then (oui) + :Confirmation de l'arrêt au serveur; + :Réinitialisation de la configuration; + stop + else (non) + if (Configuration active?) then (oui) + :Capture d'image; + :Lecture des données environnementales; + :Envoi au serveur; + if (Envoi réussi?) then (oui) + :Décrémenter le nombre d'images restantes; + else (non) + :Sauvegarder en mode hors-ligne; + endif + if (Toutes images capturées?) then (oui) + :Notification au serveur; + :Désactivation de la configuration; + stop + else (non) + :Attente du prochain cycle; + endif + else (non) + :Mode IDLE, aucune action; + stop + endif + endif + endif + else (non) + :Fonctionnement en mode dégradé; + endif +else (non) + :Mode hors ligne (timelapse_offline.py); + if (Configuration active?) then (oui) + if (Images restantes > 0?) then (oui) + :Capture d'image; + :Lecture des données environnementales; + :Sauvegarde en local; + :Décrémenter le nombre d'images restantes; + if (Toutes images capturées?) then (oui) + :Désactivation de la configuration; + stop + else (non) + :Envoi de l'intervalle au microcontrôleur; + :Attente du prochain cycle; + endif + else (non) + :Désactivation de la configuration; + stop + endif + else (non) + :Aucune configuration active; + stop + endif +endif + +stop + +@enduml \ No newline at end of file diff --git a/diagrams/raspi/03_structure_classes.puml b/diagrams/raspi/03_structure_classes.puml new file mode 100644 index 0000000..976b7c3 --- /dev/null +++ b/diagrams/raspi/03_structure_classes.puml @@ -0,0 +1,91 @@ +@startuml Structure des Classes et Composants + +skinparam { + BackgroundColor white + ClassBackgroundColor lightcyan + ClassBorderColor gray + ClassFontName Arial + ClassFontSize 12 +} + +class Config { + + BASE_DIR : string + + CONFIG_DIR : string + + PROJECT_DIR : string + + LOG_FILE : string + + CONFIG_FILE : string + + API_BASE_URL : string + + API_ENDPOINTS : dict + + DEFAULT_CONFIG : dict + -- + + ensure_directories() + + setup_logging() + + load_config() + + save_config() + + update_config(new_config) + + get(key, default) + + set(key, value) + + delete_config_file() + + decrement_remaining_images() +} + +class APIClient { + - base_url : string + - headers : dict + -- + + get_camera_status() + + upload_measurement(image_path, timestamp, temperature, humidity) + + confirm_stop() + + update_camera_config(status) + + check_connection() +} + +class TimelapseCaptureManager { + - offline_dir : string + -- + + single_capture(online) + + run_capture_sequence(online) + + sync_offline_captures() + + count_offline_captures() + - _move_to_offline(image_path, json_path) + - _cleanup_local_capture(image_path, json_path) +} + +class "timelapse_online.py" as TimelapseOnline { + + main() +} + +class "timelapse_offline.py" as TimelapseOffline { + + main() +} + +package "sensors" { + class EnvironmentalSensor { + + read_data() + } + + class Camera { + + capture_image() + } + + class MicroController { + + send_interval(interval) + } +} + +Config "1" <-- "1" TimelapseOnline : utilise +Config "1" <-- "1" TimelapseOffline : utilise +Config "1" <-- "1" TimelapseCaptureManager : utilise +APIClient "1" <-- "1" TimelapseOnline : utilise +TimelapseCaptureManager "1" <-- "1" TimelapseOnline : utilise +TimelapseCaptureManager "1" <-- "1" TimelapseOffline : utilise +TimelapseCaptureManager "1" --> "1" EnvironmentalSensor : utilise +TimelapseCaptureManager "1" --> "1" Camera : utilise +APIClient "1" --> "1" Config : utilise +TimelapseOffline ..> MicroController : utilise + +note bottom of Config : "Gestion de la configuration\nlocale et persistance" +note bottom of APIClient : "Communication avec\nle serveur distant" +note bottom of TimelapseCaptureManager : "Orchestration du processus\nde capture d'images" + +@enduml \ No newline at end of file diff --git a/diagrams/raspi/04_sequence_synchronisation.puml b/diagrams/raspi/04_sequence_synchronisation.puml new file mode 100644 index 0000000..e1ae9e5 --- /dev/null +++ b/diagrams/raspi/04_sequence_synchronisation.puml @@ -0,0 +1,78 @@ +@startuml Séquence de Synchronisation des Données + +skinparam { + BackgroundColor white + SequenceGroupBorderColor gray + SequenceGroupBodyBackgroundColor whitesmoke + ParticipantBackgroundColor lightblue + ParticipantBorderColor gray + LifeLineBorderColor gray + ArrowColor #666666 +} + +actor "Système" as System +participant "sync_offline_data.py" as Sync +participant "APIClient" as API +participant "TimelapseCaptureManager" as Manager +participant "Config" as Config +database "Stockage local" as Storage +database "Serveur API" as Server + +System -> Sync : Exécution du script +activate Sync + +Sync -> API : check_connection() +activate API +API --> Sync : Connexion disponible +deactivate API + +Sync -> Manager : count_offline_captures() +activate Manager +Manager -> Storage : Listing des dossiers offline +Storage --> Manager : Liste des captures +Manager --> Sync : Nombre de captures hors ligne +deactivate Manager + +alt Captures hors ligne disponibles + Sync -> Manager : sync_offline_captures() + activate Manager + + loop Pour chaque capture hors ligne + Manager -> Storage : Lire données JSON + activate Storage + Storage --> Manager : Données (timestamp, température, etc.) + deactivate Storage + + Manager -> Storage : Lire image + activate Storage + Storage --> Manager : Fichier image + deactivate Storage + + Manager -> API : upload_measurement() + activate API + API -> Server : POST /camera/upload + + alt Upload réussi + Server --> API : Confirmation (ID image) + API --> Manager : Succès + Manager -> Storage : Suppression des fichiers locaux + Manager -> Config : Mise à jour du statut + else Échec de l'upload + Server --> API : Erreur + API --> Manager : Échec + note right: Conservation des fichiers locaux\npour tentative ultérieure + end + + deactivate API + end + + Manager --> Sync : Nombre de captures synchronisées + deactivate Manager +else Aucune capture à synchroniser + Sync -> Sync : Fin sans action +end + +Sync --> System : Rapport de synchronisation +deactivate Sync + +@enduml \ No newline at end of file diff --git a/diagrams/raspi/05_deploiement_infrastructure.puml b/diagrams/raspi/05_deploiement_infrastructure.puml new file mode 100644 index 0000000..f4642b8 --- /dev/null +++ b/diagrams/raspi/05_deploiement_infrastructure.puml @@ -0,0 +1,69 @@ +@startuml infra_raspi + +skinparam { + BackgroundColor white + NodeBackgroundColor lightyellow + NodeBorderColor gray + AgentBackgroundColor lightcyan + AgentBorderColor gray + ArrowColor #666666 + ComponentBackgroundColor lightblue + ComponentBorderColor gray +} + +artifact "Raspbian OS" as linux + +node "Raspberry Pi" as raspi { + agent "Service Systemd" as service + artifact "timelapse.service" as timelapseService + artifact "script.sh" as script + + service --> timelapseService : gère + service --> script : exécute + + component "Scripts Python" as scripts { + artifact "timelapse_online.py" as pyOnline + artifact "timelapse_offline.py" as pyOffline + artifact "sync_offline_data.py" as pySync + } + + component "Modules Timelapse" as modules { + artifact "config.py" as config + artifact "api_client.py" as apiClient + artifact "capture.py" as capture + artifact "sensors.py" as sensors + } + + artifact "Caméra Pi" as cam + artifact "Microcontrôleur" as micro +} + +cloud "Internet" as internet { + node "Serveur API" as api_server { + database "Base de données" as db + folder "Stockage d'images" as images + } +} + +linux --> service : exécute +service --> script : lance +script --> scripts : appelle selon\nétat connexion +scripts --> modules : utilisent +modules --> cam : contrôle +modules --> micro : communique +modules --> internet : envoie données +internet --> modules : récupère configuration + +note right of service : "Démarrage au boot\net exécution périodique" +note right of scripts : "Sélection auto du mode\nselon connectivité" +note bottom of cam : "Capture des images\ndu timelapse" +note bottom of micro : "Gestion de l'intervalle\nde capture" + +legend right + Infrastructure de Déploiement Timelapse + Ce diagramme représente l'infrastructure complète + du système timelapse, depuis le service systemd + jusqu'à la communication avec le serveur distant. +endlegend + +@enduml \ No newline at end of file diff --git a/diapo_master.pdf b/diapo_master.pdf index 092b3e6..545f55f 100644 Binary files a/diapo_master.pdf and b/diapo_master.pdf differ diff --git a/diapo_master.tex b/diapo_master.tex index 998d6ab..d9d0a1b 100644 --- a/diapo_master.tex +++ b/diapo_master.tex @@ -17,6 +17,7 @@ \usepackage{xcolor} \usepackage{listings} \usepackage{fancyvrb} +\usepackage[french]{babel} % Define the dot-based progress bar \usepackage{tikz} @@ -43,148 +44,35 @@ % Introduction \section{Introduction} -\begin{frame}{Contexte et Objectifs} - \begin{itemize} - \item Présentation du projet : Caméra Timelapse - \item Contexte d'utilisation et motivation - \item Objectifs principaux du projet - \end{itemize} -\end{frame} - -\section{Exemple UML} -\begin{frame}{Exemple UML} - \begin{center} - \includegraphics[width=0.9\textwidth]{diagrams/global.png} - \end{center} -\end{frame} +\input{diapos/contexte-objectifs.tex} % Cahier des charges \section{Cahier des charges} -\begin{frame}{Spécifications et Contraintes} - \begin{itemize} - \item Fonctionnalités attendues - \item Contraintes techniques (matériel, logiciel) - \item Livrables - \end{itemize} -\end{frame} +\input{diapos/cahier-charges.tex} % Partie mécanique \section{Partie mécanique} -\begin{frame}{Partie mécanique} - \begin{itemize} - \item Présentation de la structure mécanique - \item Choix des matériaux et conception - \item Schémas ou photos du montage - \end{itemize} -\end{frame} +\input{diapos/meca.tex} % Partie électronique \section{Partie électronique} -\begin{frame}{Partie électronique} - \begin{itemize} - \item Architecture électronique - \item Composants utilisés (capteurs, microcontrôleurs, etc.) - \item Schémas électroniques - \end{itemize} -\end{frame} +\input{diapos/elec.tex} -% Partie serveur, front et application mobile -\section{Serveur, Front et Application mobile} -\begin{frame}{Serveur, Front et Application mobile} - \begin{itemize} - \item Présentation de l'architecture logicielle - \item Fonctionnalités principales du serveur - \item Aperçu du front web et de l'application mobile - \item Technologies utilisées - \end{itemize} -\end{frame} +% Partie informatique (serveur, front et application mobile) +\section{Partie informatique} +\input{diapos/info.tex} -% Partie front end -\subsection{Front end} -\begin{frame}{Front end} - \textbf{Choix des technologies :} - \begin{itemize} - \item HTML, CSS, Javascript - \item ChartJS pour la visualisation de données - \item Ajax pour la communication asynchrone - \end{itemize} - \vspace{0.5em} - \textbf{Efforts notables :} - \begin{itemize} - \item Carousel 3D animé, modulable selon le nombre de projets - \item Responsive : adaptation à la taille de la fenêtre - \item Menu déroulant pour cacher les images en excès - \item Affichage d'images compressées pour optimiser la génération - \item Style universel pour le confort utilisateur - \end{itemize} -\end{frame} - -\begin{frame}{Front end : Architecture} - \textbf{Organisation du code~:} - \begin{itemize} - \item \textbf{HTML}~: \texttt{index.html}, \texttt{pages/projet\_detail.html} - \item \textbf{CSS}~: \texttt{css/base/style.css}, \texttt{css/components/style\_menu.css}, \texttt{css/pages/style\_projet.css}, images dans \texttt{css/image/} - \item \textbf{JS}~: \texttt{js/core/} (logique principale), \texttt{js/libs/} (librairies tierces), \texttt{js/pages/} (scripts spécifiques aux pages) - \end{itemize} - \vspace{0.5em} - \textbf{Outils et automatisation~:} - \begin{itemize} - \item Déploiement automatisé avec \texttt{.gitea/workflows/deploy.yml} - \item Conteneurisation possible via \texttt{docker-compose.yml} - \item Fichier \texttt{deploy.sh} pour le déploiement manuel - \end{itemize} -\end{frame} - -\begin{frame}{Automatisation du déploiement : deploy.sh} - \textbf{Script de déploiement automatique~:} - \begin{itemize} - \item Un script bash (\texttt{deploy.sh}) a été développé par Ethan pour automatiser le déploiement du front-end. - \item Il permet de mettre à jour rapidement la version en ligne lors du développement continu. - \item Ce script facilite l'intégration des modifications et réduit les risques d'erreur humaine lors des mises à jour. - \item Il s'intègre dans la chaîne de développement pour accélérer les cycles de test et de validation. - \end{itemize} -\end{frame} - -\begin{frame}{Front end (suite)} - \textbf{Difficultés rencontrées :} - \begin{itemize} - \item Interface optimale entre le front end, le serveur et l'application mobile - \item Évolution constante des routes et de la logique serveur - \item Adaptation aux changements du modèle de données - \end{itemize} - \vspace{0.5em} - \textbf{Apprentissages :} - \begin{itemize} - \item Génération de 3D en HTML et CSS - \item Manipulation d'images et de vidéos - \end{itemize} -\end{frame} +% Partie multimédia +\section{Traitement multimédia} +\input{diapos/multi.tex} % Démonstration \section{Démonstration} -\begin{frame}{Démonstration} - \begin{itemize} - \item Vidéo ou démonstration en direct du projet - \item Points forts à montrer - \end{itemize} -\end{frame} +\input{diapos/demo.tex} % Conclusion \section{Conclusion} -\begin{frame}{Bilan et perspectives} - \begin{block}{Résumé} - \begin{itemize} - \item Synthèse des apports du projet - \item Retour d'expérience - \end{itemize} - \end{block} - \begin{alertblock}{Perspectives} - \begin{itemize} - \item Améliorations possibles - \item Suites envisagées - \end{itemize} - \end{alertblock} -\end{frame} +\input{diapos/conclusion.tex} % Remerciements \begin{frame}{Remerciements} diff --git a/diapos/cahier-charges.tex b/diapos/cahier-charges.tex new file mode 100644 index 0000000..2727331 --- /dev/null +++ b/diapos/cahier-charges.tex @@ -0,0 +1,112 @@ +\begin{frame}{Spécifications et Cahier des Charges} + \begin{itemize} + \item Fonctionnalités attendues du système complet + \item Contraintes techniques à respecter + \item Livrables du projet + \end{itemize} +\end{frame} + +\begin{frame}{Fonctionnalités principales} + \begin{itemize} + \item \textbf{Acquisition d'images} + \begin{itemize} + \item Capture programmable à intervalles réguliers + \item Résolution suffisante pour générer des vidéos HD + \item Stabilité et qualité d'image optimales + \end{itemize} + \item \textbf{Gestion des données} + \begin{itemize} + \item Stockage local des images sur la Raspberry Pi + \item Transmission des images vers un serveur distant + \item Optimisation de la consommation d'énergie et de bande passante + \end{itemize} + \item \textbf{Interfaces utilisateur} + \begin{itemize} + \item Interface web et application mobile pour configuration + \item Visualisation des images et vidéos générées + \item Informations en temps réel sur l'état de la caméra + \end{itemize} + \end{itemize} +\end{frame} + +\begin{frame}{Contraintes du projet} + \begin{columns} + \begin{column}{0.5\textwidth} + \textbf{Contraintes techniques} + \begin{itemize} + \item Autonomie énergétique (batterie + panneau solaire) + \item Résistance aux intempéries (boîtier IP65) + \item Connectivité réseau fiable + \item Capacité de stockage suffisante + \end{itemize} + \end{column} + \begin{column}{0.5\textwidth} + \textbf{Contraintes organisationnelles} + \begin{itemize} + \item Budget limité + \item Délais de développement contraints + \item Coordination entre équipes multidisciplinaires + \item Disponibilité des ressources matérielles + \end{itemize} + \end{column} + \end{columns} +\end{frame} + +\begin{frame}{Architecture globale du système} + \begin{center} + \includegraphics[width=0.8\textwidth]{out/diagrams/global/global.png} + \end{center} + \vspace{0.5em} + \begin{itemize} + \item Approche modulaire facilitant le développement parallèle + \item Communication entre modules via interfaces standardisées + \item Séparation des responsabilités : acquisition, traitement, interface + \end{itemize} +\end{frame} + +\begin{frame}{Livrables} + \begin{itemize} + \item \textbf{Prototype de caméra timelapse fonctionnel} comprenant: + \begin{itemize} + \item Système électronique complet + \item Boîtier résistant aux intempéries + \item Logiciel embarqué sur Raspberry Pi + \end{itemize} + \item \textbf{Logiciels et interfaces} + \begin{itemize} + \item Serveur de traitement et stockage + \item Interface web + \item Application mobile Android + \end{itemize} + \item \textbf{Documentation} + \begin{itemize} + \item Plans et schémas techniques + \item Rapport de projet détaillé + \item Plan Qualité Projet (PQP) + \end{itemize} + \end{itemize} +\end{frame} + +\begin{frame}{Indicateurs de performance} + \begin{columns} + \begin{column}{0.5\textwidth} + \textbf{Indicateurs de gestion} + \begin{itemize} + \item Tâches complétées par semaine + \item Pourcentage d'avancement vs plan + \item Respect des délais prévus + \item Nouvelles compétences acquises + \end{itemize} + \end{column} + + \begin{column}{0.5\textwidth} + \textbf{Indicateurs techniques} + \begin{itemize} + \item Autonomie énergétique du système + \item Fiabilité des transmissions de données + \item Qualité des vidéos générées + \item Score de satisfaction utilisateur + \end{itemize} + \end{column} + \end{columns} +\end{frame} \ No newline at end of file diff --git a/diapos/conclusion.tex b/diapos/conclusion.tex new file mode 100644 index 0000000..35a0b52 --- /dev/null +++ b/diapos/conclusion.tex @@ -0,0 +1,223 @@ +\begin{frame}{Bilan et perspectives} + \begin{block}{Résumé} + \begin{itemize} + \item Synthèse des apports du projet + \item Retour d'expérience + \end{itemize} + \end{block} + \begin{alertblock}{Perspectives} + \begin{itemize} + \item Améliorations possibles + \item Suites envisagées + \end{itemize} + \end{alertblock} +\end{frame} + +\begin{frame}{Bilan du projet} + \begin{columns} + \begin{column}{0.5\textwidth} + \textbf{Objectifs atteints :} + \begin{itemize} + \item Système fonctionnel et autonome + \item Interface utilisateur intuitive + \item Qualité d'image satisfaisante + \item Communication fiable entre composants + \item Solution complète de bout en bout + \end{itemize} + \end{column} + \begin{column}{0.5\textwidth} + \textbf{Retour d'expérience :} + \begin{itemize} + \item Travail en équipe pluridisciplinaire + \item Gestion des contraintes techniques + \item Adaptation aux imprévus + \item Intégration de multiples technologies + \item Respect des délais et du budget + \end{itemize} + \end{column} + \end{columns} +\end{frame} + +\begin{frame}{Difficultés rencontrées et solutions} + \begin{itemize} + \item \textbf{Autonomie énergétique} + \begin{itemize} + \item Difficulté : Consommation élevée du Raspberry Pi + \item Solution : Mode veille optimisé et panneau solaire dimensionné + \end{itemize} + \item \textbf{Transmission des données} + \begin{itemize} + \item Difficulté : Connexion instable en zone reculée + \item Solution : File d'attente et compression intelligente + \end{itemize} + \item \textbf{Intégration des composants} + \begin{itemize} + \item Difficulté : Espace limité et contraintes thermiques + \item Solution : Conception 3D optimisée et refroidissement passif + \end{itemize} + \end{itemize} +\end{frame} + +\begin{frame}{Perspectives d'évolution} + \begin{columns} + \begin{column}{0.5\textwidth} + \textbf{Améliorations techniques :} + \begin{itemize} + \item Réduction de la consommation énergétique + \item Augmentation de la résolution (8K) + \item Intégration de l'IA pour traitement avancé + \item Optimisation pour conditions extrêmes + \end{itemize} + \end{column} + \begin{column}{0.5\textwidth} + \textbf{Nouvelles fonctionnalités :} + \begin{itemize} + \item Détection automatique d'événements + \item Contrôle par commande vocale + \item Intégration avec drones pour vues dynamiques + \item Analyses prédictives des phénomènes observés + \end{itemize} + \end{column} + \end{columns} +\end{frame} + +\begin{frame}{Applications futures} + \begin{itemize} + \item \textbf{Domaine scientifique} + \begin{itemize} + \item Surveillance environnementale + \item Étude des écosystèmes + \item Documentation des changements climatiques + \end{itemize} + \item \textbf{Domaine industriel} + \begin{itemize} + \item Suivi de chantiers complexes + \item Contrôle de processus industriels + \item Documentation pour assurances et contentieux + \end{itemize} + \item \textbf{Domaine artistique et médiatique} + \begin{itemize} + \item Productions audiovisuelles professionnelles + \item Installations artistiques interactives + \item Documentation d'événements culturels + \end{itemize} + \end{itemize} +\end{frame} + +\begin{frame}{Mot de la fin} + \begin{center} + \Large\textbf{Merci pour votre attention !} + + \vspace{1cm} + + \normalsize + Des questions ? + \end{center} +\end{frame} + +\begin{frame}{Conclusion} + \begin{itemize} + \item Réalisation d'un système complet de caméra timelapse autonome + \item Approche multi-disciplinaire : mécanique, électronique et informatique + \item Méthodologie agile et développement en cycle en V avec itérations + \item Tous les objectifs initiaux atteints avec succès + \end{itemize} +\end{frame} + +\begin{frame}{Récapitulatif du projet} + \begin{columns} + \begin{column}{0.5\textwidth} + \textbf{Réalisations techniques :} + \begin{itemize} + \item Boîtier robuste et résistant aux intempéries + \item Système électronique autonome + \item Infrastructure serveur complète + \item Interfaces web et mobile fonctionnelles + \end{itemize} + \end{column} + \begin{column}{0.5\textwidth} + \textbf{Résultats obtenus :} + \begin{itemize} + \item Prototype fonctionnel + \item Interface utilisateur intuitive + \item Qualité des timelapses générés + \item Fiabilité du système complet + \end{itemize} + \end{column} + \end{columns} +\end{frame} + +\begin{frame}{Gestion des risques} + \begin{center} + \begin{tabular}{|p{4cm}|p{3.5cm}|p{3.5cm}|} + \hline + \textbf{Risques identifiés} & \textbf{Impact potentiel} & \textbf{Solutions mises en œuvre} \\ + \hline + Intégration mécatronique & Délais, coûts & Communication renforcée \\ + \hline + Dysfonctionnement serveur & Pertes de données & Système robuste, sauvegarde \\ + \hline + Manque de ressources & Délais & Ressources personnelles \\ + \hline + \end{tabular} + \end{center} + \vspace{0.5em} + \begin{itemize} + \item Analyse précoce des risques + \item Actions préventives efficaces + \item Réactivité face aux problèmes rencontrés + \end{itemize} +\end{frame} + +\begin{frame}{Compétences développées} + \begin{itemize} + \item \textbf{Compétences techniques :} + \begin{itemize} + \item Conception mécanique et fabrication additive + \item Conception électronique et intégration + \item Développement logiciel full-stack (serveur, web, mobile) + \item Administration système et DevOps + \end{itemize} + \item \textbf{Compétences transversales :} + \begin{itemize} + \item Gestion de projet agile + \item Communication interdisciplinaire + \item Résolution de problèmes complexes + \item Documentation technique + \end{itemize} + \end{itemize} +\end{frame} + +\begin{frame}{Perspectives d'amélioration} + \begin{itemize} + \item \textbf{Améliorations techniques possibles :} + \begin{itemize} + \item Optimisation de l'autonomie énergétique + \item Ajout de capteurs environnementaux supplémentaires + \item Amélioration des algorithmes de traitement d'images + \item Interface de configuration plus complète + \end{itemize} + \item \textbf{Évolutions potentielles :} + \begin{itemize} + \item Support pour plusieurs caméras synchronisées + \item Intégration d'intelligence artificielle pour analyse + \item Version commercialisable avec documentation utilisateur + \item Extension à d'autres usages (surveillance, etc.) + \end{itemize} + \end{itemize} +\end{frame} + +\begin{frame}{Remerciements et questions} + \begin{center} + \large\textbf{Merci pour votre attention} + \vspace{1.5em} + + \normalsize + Projet réalisé par\\ + THIEFFRY Raphaël, HUA Olivier, RIBETTE Baptiste,\\ + PUYAUBREAU Ethan et RUSSAC Antonin + \vspace{1.5em} + + \large\textbf{Questions ?} + \end{center} +\end{frame} \ No newline at end of file diff --git a/diapos/contexte-objectifs.tex b/diapos/contexte-objectifs.tex new file mode 100644 index 0000000..79c8b4a --- /dev/null +++ b/diapos/contexte-objectifs.tex @@ -0,0 +1,99 @@ +\begin{frame}{Contexte et Objectifs} + \begin{itemize} + \item Création d'une caméra timelapse autonome et connectée + \item Développement complet : matériel, logiciel et interfaces utilisateur + \item Utilisation d'une Raspberry Pi et d'un module caméra fournis + \end{itemize} +\end{frame} + +\begin{frame}{Qu'est-ce qu'un Timelapse?} + \begin{columns} + \begin{column}{0.6\textwidth} + \begin{itemize} + \item Technique photographique qui compresse le temps + \item Capture d'images à intervalles réguliers + \item Assemblées en vidéo à fréquence normale (24-30 fps) + \item Permet d'observer des phénomènes lents (construction, floraison, etc.) + \end{itemize} + \end{column} + \begin{column}{0.4\textwidth} + \centering + % Image exemple d'un timelapse + [Image exemple de timelapse] + \end{column} + \end{columns} +\end{frame} + +\begin{frame}{Objectifs du projet} + \begin{itemize} + \item \textbf{Objectif principal :} Infrastructure matérielle et logicielle permettant la création d'une vidéo à partir d'une série d'images capturées via une caméra sans fil + \item \textbf{Objectifs secondaires :} + \begin{itemize} + \item Créer un serveur de traitement et stockage + \item Développer une interface d'accès Web + \item Concevoir une application mobile + \item Fabriquer un boîtier résistant aux intempéries + \item Concevoir une carte électronique pour gérer l'énergie + \end{itemize} + \end{itemize} +\end{frame} + +\begin{frame}{Périmètre du projet} + \begin{columns} + \begin{column}{0.5\textwidth} + \textbf{Informatique :} + \begin{itemize} + \item Traitement et stockage des données + \item Serveur, interfaces Web et Android + \item Publication de l'application + \end{itemize} + + \textbf{Électronique :} + \begin{itemize} + \item Système autonome d'alimentation + \item Gestion de la consommation d'énergie + \item Protocoles de communication + \end{itemize} + \end{column} + + \begin{column}{0.5\textwidth} + \textbf{Mécanique :} + \begin{itemize} + \item Boîtier étanche et robuste + \item Système de fixation adaptable + \item Facilité de montage/démontage + \end{itemize} + + \textbf{Hors périmètre :} + \begin{itemize} + \item Conception de la caméra + \item Traitement d'images avancé + \item Conception du matériel informatique + \end{itemize} + \end{column} + \end{columns} +\end{frame} + +\begin{frame}{Applications visées} + \begin{itemize} + \item \textbf{Projets de construction} + \begin{itemize} + \item Suivi de l'évolution des chantiers + \item Documentation du processus de construction + \end{itemize} + \item \textbf{Phénomènes naturels} + \begin{itemize} + \item Croissance des plantes, floraison + \item Événements météorologiques, lever/coucher de soleil + \end{itemize} + \item \textbf{Événements de longue durée} + \begin{itemize} + \item Expositions, événements publics + \end{itemize} + \item \textbf{Projets artistiques} + \begin{itemize} + \item Création de contenu visuel + \item Narration visuelle accélérée + \end{itemize} + \end{itemize} +\end{frame} \ No newline at end of file diff --git a/diapos/demo.tex b/diapos/demo.tex new file mode 100644 index 0000000..fd56791 --- /dev/null +++ b/diapos/demo.tex @@ -0,0 +1,97 @@ +\begin{frame}{Démonstration} + \begin{center} + \huge\textbf{Démonstration du projet} + \vspace{1em} + + \large Présentation du prototype fonctionnel + \end{center} +\end{frame} + +\begin{frame}{Prototype intégré} + \begin{columns} + \begin{column}{0.6\textwidth} + \textbf{Présentation du prototype :} + \begin{itemize} + \item Boîtier complet avec tous les composants intégrés + \item Système électronique fonctionnel + \item Connexion au serveur et démonstration de capture + \item Tests des différentes fonctionnalités + \end{itemize} + \end{column} + \begin{column}{0.4\textwidth} + \centering + % Image du prototype final + [Photo du prototype complet] + \end{column} + \end{columns} +\end{frame} + +\begin{frame}{Interface web} + \begin{center} + % Capture d'écran de l'interface web + [Capture d'écran de l'interface web] + \vspace{0.5em} + \textit{Interface de gestion des projets timelapse} + \end{center} + \vspace{0.5em} + Démonstration des fonctionnalités : + \begin{itemize} + \item Création et configuration d'un projet + \item Visualisation des images capturées + \item Génération et visualisation d'une vidéo timelapse + \item Configuration des paramètres de capture + \end{itemize} +\end{frame} + +\begin{frame}{Application Android} + \begin{center} + % Capture d'écran de l'application mobile + [Capture d'écran de l'application mobile] + \vspace{0.5em} + \textit{Application mobile de contrôle et visualisation} + \end{center} + \vspace{0.5em} + Démonstration des fonctionnalités : + \begin{itemize} + \item Connexion et authentification + \item Consultation des projets en cours + \item Configuration à distance de la caméra + \item Visualisation des timelapses générés + \end{itemize} +\end{frame} + +\begin{frame}{Vidéos timelapses générées} + \begin{center} + % Exemple de timelapses générés + [Exemples de timelapses générés] + \vspace{0.5em} + \textit{Résultats obtenus avec le système développé} + \end{center} + \vspace{0.5em} + \begin{itemize} + \item Présentation de plusieurs exemples de timelapse + \item Démonstration de différents intervalles et durées + \item Qualité d'image et stabilité du résultat + \item Comparaison avant/après traitement + \end{itemize} +\end{frame} + +\begin{frame}{Performances et résultats} + \begin{itemize} + \item \textbf{Autonomie énergétique :} + \begin{itemize} + \item Test en conditions réelles sur plusieurs jours + \item Données de consommation et recharge + \end{itemize} + \item \textbf{Fiabilité de la transmission :} + \begin{itemize} + \item Statistiques de transmissions réussies + \item Tests en conditions de connexion dégradée + \end{itemize} + \item \textbf{Qualité du traitement :} + \begin{itemize} + \item Stabilité des vidéos générées + \item Efficacité des algorithmes de correction + \end{itemize} + \end{itemize} +\end{frame} \ No newline at end of file diff --git a/diapos/elec.tex b/diapos/elec.tex new file mode 100644 index 0000000..8adc073 --- /dev/null +++ b/diapos/elec.tex @@ -0,0 +1,141 @@ +\begin{frame}{Partie électronique} + \begin{itemize} + \item Conception du système électronique autonome + \item Gestion intelligente de l'énergie + \item Intégration des composants avec la Raspberry Pi + \item Protocoles de communication + \end{itemize} +\end{frame} + +\begin{frame}{Composants électroniques principaux} + \begin{columns} + \begin{column}{0.5\textwidth} + \textbf{Unité de traitement :} + \begin{itemize} + \item Raspberry Pi 4B avec Raspbian + \item Module caméra fourni par l'école + \item Microcontrôleur STM32 pour gestion d'énergie + \item Capteur hygrométrique + \end{itemize} + + \textbf{Connectivité :} + \begin{itemize} + \item WiFi intégré à la Raspberry Pi + \item Connexions filaires sécurisées + \end{itemize} + \end{column} + + \begin{column}{0.5\textwidth} + \textbf{Alimentation :} + \begin{itemize} + \item Batterie de 6€ + \item Panneaux solaires + \item Modules d'alimentation à découpage (2) + \item Système de gestion d'énergie + \end{itemize} + + \textbf{Composants additionnels :} + \begin{itemize} + \item Transistors (2 en 1) + \item LED indicatrices d'état + \item Résistances et condensateurs + \item Connectique et câbles + \end{itemize} + \end{column} + \end{columns} +\end{frame} + +\begin{frame}{Architecture électronique} + \begin{center} + \includegraphics[width=0.8\textwidth]{out/diagrams/raspi/01_architecture_generale/Architecture Générale du Système Timelapse.png} + \end{center} + \vspace{0.5em} + \begin{itemize} + \item Conception modulaire avec connecteurs standards + \item Protection contre les surtensions et court-circuits + \item PCB optimisé pour minimiser les interférences + \end{itemize} +\end{frame} + +\begin{frame}{Conception et fabrication du PCB} + \begin{itemize} + \item \textbf{Outils de conception :} + \begin{itemize} + \item Altium Designer pour conception et routage + \item STM32 CubeIDE et STMProgrammer pour le développement logiciel + \end{itemize} + \item \textbf{Processus de fabrication :} + \begin{itemize} + \item Utilisation d'une graveuse mécanique + \item PCB vierge (6€) + \item Assemblage manuel des composants + \item Tests de fonctionnement + \end{itemize} + \item \textbf{Approche itérative :} + \begin{itemize} + \item Versions successives documentées + \item Répertoires numérotés par version de production + \item Archives détachées des répertoires de travail + \end{itemize} + \end{itemize} +\end{frame} + +\begin{frame}{Gestion de l'énergie} + \begin{columns} + \begin{column}{0.5\textwidth} + \textbf{Enjeux énergétiques :} + \begin{itemize} + \item Autonomie complète en extérieur + \item Optimisation de la consommation + \item Gestion des cycles charge/décharge + \item Adaptation aux conditions météo + \end{itemize} + \end{column} + + \begin{column}{0.5\textwidth} + \textbf{Solutions implémentées :} + \begin{itemize} + \item Circuit de charge intelligent + \item Mode économie d'énergie + \item Surveillance de la batterie + \item Protection contre décharge profonde + \end{itemize} + \end{column} + \end{columns} +\end{frame} + +\begin{frame}{Flux de traitement des données} + \begin{center} + \includegraphics[width=0.8\textwidth]{out/diagrams/raspi/02_flux_capture/Flux du Processus de Capture d'Images.png} + \end{center} + \vspace{0.3em} + \begin{itemize} + \item Capture et traitement d'images optimisés + \item Stockage temporaire sur la Raspberry Pi + \item Synchronisation avec le serveur distant + \end{itemize} +\end{frame} + +\begin{frame}{Défis électroniques} + \begin{columns} + \begin{column}{0.5\textwidth} + \textbf{Défis rencontrés :} + \begin{itemize} + \item Intégration mécatronique + \item Problématiques d'autonomie énergétique + \item Fiabilité des connexions + \item Gestion de la chaleur + \end{itemize} + \end{column} + + \begin{column}{0.5\textwidth} + \textbf{Solutions apportées :} + \begin{itemize} + \item Communication constante avec l'équipe mécanique + \item Design électronique à basse consommation + \item Connecteurs sécurisés et isolés + \item Systèmes de dissipation thermique + \end{itemize} + \end{column} + \end{columns} +\end{frame} \ No newline at end of file diff --git a/diapos/info.tex b/diapos/info.tex new file mode 100644 index 0000000..83c634d --- /dev/null +++ b/diapos/info.tex @@ -0,0 +1,188 @@ +\begin{frame}{Architecture informatique} + \begin{itemize} + \item Développement basé sur méthodologie agile + \item Architecture client-serveur distribuée + \item Trois composants principaux : Backend, Frontend, Application mobile + \item Infrastructure robuste et sécurisée + \end{itemize} +\end{frame} + +\begin{frame}{Architecture globale} + \begin{center} + \includegraphics[width=0.8\textwidth]{out/diagrams/architecture/architecture_timelapse.png} + \end{center} + \vspace{0.3em} + \begin{itemize} + \item Architecture modulaire avec interfaces standardisées + \item Communication via API REST sécurisée + \item Séparation claire des responsabilités + \item Intégration continue et déploiement automatisé + \end{itemize} +\end{frame} + +\begin{frame}{Infrastructure et déploiement} + \begin{center} + \includegraphics[width=0.8\textwidth]{out/diagrams/backend/backend5/Déploiement.png} + \end{center} + \vspace{0.3em} + \begin{itemize} + \item Applications hébergées dans des conteneurs Docker + \item Machine virtuelle Ubuntu Server sur hyperviseur Proxmox + \item Trois niveaux d'abstraction facilitant maintenance et sauvegarde + \item Déploiement et mise à jour automatisés via CI/CD + \end{itemize} +\end{frame} + +\begin{frame}{Structure des classes et composants} + \begin{center} + \includegraphics[width=0.8\textwidth]{out/diagrams/raspi/03_structure_classes/Structure des Classes et Composants.png} + \end{center} + \vspace{0.3em} + \begin{itemize} + \item Organisation objet orientée domaines + \item Séparation des responsabilités + \item Interfaces clairement définies entre composants + \end{itemize} +\end{frame} + +\begin{frame}{Synchronisation des données} + \begin{center} + \includegraphics[width=0.75\textwidth]{out/diagrams/raspi/04_sequence_synchronisation/Séquence de Synchronisation des Données.png} + \end{center} + \vspace{0.3em} + \begin{itemize} + \item Processus robuste de transfert des images + \item Gestion des échecs de connexion + \item Reprise de transfert automatique + \end{itemize} +\end{frame} + +\begin{frame}{Backend - Technologies et architecture} + \begin{columns} + \begin{column}{0.5\textwidth} + \textbf{Technologies utilisées :} + \begin{itemize} + \item Node.js + Express + \item FFMPEG pour traitement vidéo + \item NPM pour la gestion des dépendances + \item Docker pour la conteneurisation + \end{itemize} + \end{column} + \begin{column}{0.5\textwidth} + \textbf{Architecture :} + \begin{itemize} + \item Architecture MVC + \item API RESTful + \item Traitement asynchrone + \item Gestion des erreurs robuste + \end{itemize} + \end{column} + \end{columns} + \begin{center} + \includegraphics[width=0.5\textwidth]{out/diagrams/backend/backend2/Architecture MVC.png} + \end{center} +\end{frame} + +\begin{frame}{Backend - Modèles de données et traitement} + \begin{columns} + \begin{column}{0.5\textwidth} + \begin{center} + \includegraphics[width=\textwidth]{out/diagrams/backend/backend1/Modèles de données.png} + \end{center} + \end{column} + \begin{column}{0.5\textwidth} + \begin{center} + \includegraphics[width=\textwidth]{out/diagrams/backend/backend3/Création de vidéo.png} + \end{center} + \end{column} + \end{columns} + \vspace{0.3em} + \begin{itemize} + \item Modèles structurés pour stockage et traitement efficaces + \item Algorithme optimisé pour la création de vidéos timelapse + \end{itemize} +\end{frame} + +\begin{frame}{Frontend Web} + \begin{columns} + \begin{column}{0.6\textwidth} + \textbf{Technologies et organisation :} + \begin{itemize} + \item Javascript (jQuery) + HTML + CSS + \item Organisation modulaire du code + \item Style universel pour confort utilisateur + \item Interface responsive et intuitive + \end{itemize} + \vspace{0.5em} + \textbf{Fonctionnalités principales :} + \begin{itemize} + \item Gestion des projets timelapse + \item Visualisation des images et vidéos + \item Configuration des paramètres + \item Carousel 3D animé et modulable + \end{itemize} + \end{column} + \begin{column}{0.4\textwidth} + \begin{center} + \includegraphics[width=\textwidth]{out/diagrams/frontend/frontend3/frontend3.png} + \end{center} + \end{column} + \end{columns} +\end{frame} + +\begin{frame}{Application Mobile Android} + \begin{columns} + \begin{column}{0.6\textwidth} + \textbf{Technologies :} + \begin{itemize} + \item Kotlin avec Retrofit et Glide + \item XML pour layouts + \item Android API native + \end{itemize} + \vspace{0.5em} + \textbf{Fonctionnalités :} + \begin{itemize} + \item Visualisation des projets et timelapses + \item Configuration à distance des caméras + \item Mode hors-ligne avec synchronisation + \item Notifications en temps réel + \end{itemize} + \end{column} + \begin{column}{0.4\textwidth} + \begin{center} + \includegraphics[width=\textwidth]{UML Schematique android.png} + \end{center} + \end{column} + \end{columns} +\end{frame} + +\begin{frame}{Intégration et flux de données} + \begin{center} + \includegraphics[width=0.8\textwidth]{out/diagrams/global_interspec_lite/global_interspec_lite.png} + \end{center} + \vspace{0.3em} + \begin{itemize} + \item Communication fluide entre tous les composants + \item Interfaces standardisées pour l'échange de données + \item Gestion des erreurs et reprise sur incident + \end{itemize} +\end{frame} + +\begin{frame}{Sécurité et optimisation} + \begin{itemize} + \item \textbf{Sécurité :} + \begin{itemize} + \item Authentification sécurisée + \item Exposition sécurisée via reverse proxy + \item Chiffrement des communications + \item VPN et re-routage d'adresses IP + \end{itemize} + \item \textbf{Optimisation :} + \begin{itemize} + \item Adaptation de la qualité selon la connexion + \item Mise en cache des données pour fonctionnement hors-ligne + \item Traitement asynchrone des tâches lourdes + \item Compression adaptative des images et vidéos + \end{itemize} + \end{itemize} +\end{frame} \ No newline at end of file diff --git a/diapos/meca.tex b/diapos/meca.tex new file mode 100644 index 0000000..5fd87cf --- /dev/null +++ b/diapos/meca.tex @@ -0,0 +1,111 @@ +\begin{frame}{Partie mécanique} + \begin{itemize} + \item Conception d'un boîtier robuste et adapté + \item Choix des matériaux pour environnement extérieur + \item Système de fixation modulaire et ajustable + \item Protection des composants électroniques + \end{itemize} +\end{frame} + +\begin{frame}{Conception mécanique} + \begin{columns} + \begin{column}{0.6\textwidth} + \textbf{Caractéristiques principales :} + \begin{itemize} + \item Boîtier étanche IP65 (résistant aux intempéries) + \item Support orientable pour cadrage optimal + \item Fixation universelle (trépied, rail, mur) + \item Accès facile aux composants pour maintenance + \item Ventilation passive pour éviter la surchauffe + \end{itemize} + \end{column} + \begin{column}{0.4\textwidth} + \centering + % Image du prototype électromécanique + [Image du prototype boîtier] + \end{column} + \end{columns} +\end{frame} + +\begin{frame}{Méthodologie de conception} + \begin{itemize} + \item \textbf{Approche par cycle en V avec itérations} + \begin{itemize} + \item Phase d'analyse des besoins + \item Spécifications techniques détaillées + \item Conception générale et détaillée + \item Prototypages successifs et tests + \end{itemize} + \item \textbf{Intégration avec la partie électronique} + \begin{itemize} + \item Communication constante entre équipes mécanique et électronique + \item Conception adaptée aux contraintes d'assemblage + \item Marges de sécurité pour ajustements finaux + \end{itemize} + \end{itemize} +\end{frame} + +\begin{frame}{Processus de fabrication} + \begin{itemize} + \item \textbf{Prototypage :} + \begin{itemize} + \item Conception 3D sur Solidworks + \item Impression 3D avec Bambu Lab X1S (PLA) + \item Tests d'étanchéité et de résistance + \item Organisation de répertoires "RELEASE" pour archiver chaque prototype + \end{itemize} + \item \textbf{Optimisations :} + \begin{itemize} + \item Réduction du poids tout en maintenant la solidité + \item Amélioration de la ventilation interne + \item Simplification du montage/démontage + \item Passages de câbles optimisés + \end{itemize} + \end{itemize} +\end{frame} + +\begin{frame}{Choix des matériaux} + \begin{itemize} + \item \textbf{Matériau principal : PLA} + \begin{itemize} + \item Facilité d'impression et précision dimensionnelle + \item Coût raisonnable (20€/kg) + \item Rigidité adaptée aux contraintes mécaniques + \end{itemize} + \item \textbf{Analyse et sélection} + \begin{itemize} + \item Utilisation du logiciel CES pour le choix du matériau + \item Calculs de contraintes avec RDM6 + \item Compromis entre légèreté, résistance et coût + \end{itemize} + \item \textbf{Éléments complémentaires} + \begin{itemize} + \item Visserie standard pour faciliter maintenance + \item Joints d'étanchéité sur mesure + \item Supports anti-vibration pour la caméra + \end{itemize} + \end{itemize} +\end{frame} + +\begin{frame}{Défis mécaniques rencontrés} + \begin{columns} + \begin{column}{0.5\textwidth} + \textbf{Défis} + \begin{itemize} + \item Intégration mécatronique complexe + \item Étanchéité vs ventilation + \item Poids vs rigidité + \item Tolérance dimensionnelle de l'impression 3D + \end{itemize} + \end{column} + \begin{column}{0.5\textwidth} + \textbf{Solutions} + \begin{itemize} + \item Communication renforcée entre équipes + \item Systèmes d'aération avec filtres + \item Nervures de renfort dans la conception + \item Tests et itérations multiples + \end{itemize} + \end{column} + \end{columns} +\end{frame} \ No newline at end of file diff --git a/diapos/multi.tex b/diapos/multi.tex new file mode 100644 index 0000000..b71c250 --- /dev/null +++ b/diapos/multi.tex @@ -0,0 +1,130 @@ +\begin{frame}{Traitement multimédia} + \begin{itemize} + \item Acquisition et traitement des images + \item Génération automatisée des timelapses + \item Optimisation des processus de traitement + \item Compatibilité avec différents formats et résolutions + \end{itemize} +\end{frame} + +\begin{frame}{Acquisition d'images} + \begin{columns} + \begin{column}{0.5\textwidth} + \textbf{Paramètres de capture :} + \begin{itemize} + \item Résolution : jusqu'à HD (1920×1080) + \item Format : JPEG optimisé + \item Intervalles configurables via l'interface + \item Exposition automatique adaptative + \end{itemize} + \end{column} + \begin{column}{0.5\textwidth} + \textbf{Optimisations :} + \begin{itemize} + \item Adaptation auto selon les conditions + \item Balance des blancs automatique + \item Compression intelligente + \item Stockage efficient des métadonnées + \end{itemize} + \end{column} + \end{columns} +\end{frame} + +\begin{frame}{Processus de capture et traitement} + \begin{center} + \includegraphics[width=0.8\textwidth]{out/diagrams/backend/backend3/Création de vidéo.png} + \end{center} + \vspace{0.3em} + \begin{itemize} + \item Acquisition planifiée des images + \item Prétraitement sur la Raspberry Pi + \item Transmission sécurisée vers le serveur + \item Assemblage en vidéo via FFMPEG + \end{itemize} +\end{frame} + +\begin{frame}{Traitement des images} + \begin{itemize} + \item \textbf{Pré-traitement sur la Raspberry Pi :} + \begin{itemize} + \item Validation de la qualité de l'image + \item Compression adaptative selon la connexion + \item Stockage temporaire sécurisé + \item Préparation pour transmission + \end{itemize} + \item \textbf{Traitement sur le serveur :} + \begin{itemize} + \item Normalisation des images + \item Correction de luminosité entre les prises + \item Algorithme anti-scintillement (deflicker) + \item Détection et élimination des images défectueuses + \end{itemize} + \end{itemize} +\end{frame} + +\begin{frame}{Génération de timelapses} + \begin{columns} + \begin{column}{0.5\textwidth} + \textbf{Pipeline de traitement :} + \begin{enumerate} + \item Importation et vérification des images + \item Traitement par lot avec FFMPEG + \item Ajout d'effets et transitions + \item Encodage optimisé (H.264/H.265) + \item Génération de vignettes pour les interfaces + \end{enumerate} + \end{column} + \begin{column}{0.5\textwidth} + \textbf{Options de personnalisation :} + \begin{itemize} + \item Vitesse de lecture ajustable + \item Résolution de sortie configurable + \item Options de qualité/compression + \item Possibilité d'ajouter des titres + \item Formats de sortie multiples + \end{itemize} + \end{column} + \end{columns} +\end{frame} + +\begin{frame}{Optimisations du traitement} + \begin{itemize} + \item \textbf{Performance serveur :} + \begin{itemize} + \item Traitement asynchrone des requêtes + \item File d'attente pour les tâches intensives + \item Parallélisation des opérations quand possible + \item Cache intelligent des ressources + \end{itemize} + \item \textbf{Optimisation bande passante :} + \begin{itemize} + \item Compression adaptative selon la qualité du réseau + \item Transfert par lots d'images + \item Reprise automatique des transferts interrompus + \item Priorisation des données essentielles + \end{itemize} + \end{itemize} +\end{frame} + +\begin{frame}{Défis et solutions techniques} + \begin{columns} + \begin{column}{0.5\textwidth} + \textbf{Défis :} + \begin{itemize} + \item Variations de luminosité entre prises + \item Connexion réseau intermittente + \item Ressources limitées sur la Raspberry Pi + \item Conservation de la qualité d'image + \end{itemize} + \end{column} + \begin{column}{0.5\textwidth} + \textbf{Solutions :} + \begin{itemize} + \item Algorithmes de normalisation + \item Système de mise en cache et synchronisation + \item Optimisation du code pour faible consommation + \item Paramètres de compression intelligents + \end{itemize} + \end{column} + \end{columns} +\end{frame} \ No newline at end of file diff --git a/out/diagrams/architecture/architecture_timelapse.png b/out/diagrams/architecture/architecture_timelapse.png new file mode 100644 index 0000000..a530912 Binary files /dev/null and b/out/diagrams/architecture/architecture_timelapse.png differ diff --git a/out/diagrams/backend/backend1/Modèles de données.png b/out/diagrams/backend/backend1/Modèles de données.png new file mode 100644 index 0000000..0b278e4 Binary files /dev/null and b/out/diagrams/backend/backend1/Modèles de données.png differ diff --git a/out/diagrams/backend/backend2/Architecture MVC.png b/out/diagrams/backend/backend2/Architecture MVC.png new file mode 100644 index 0000000..7a2e3cc Binary files /dev/null and b/out/diagrams/backend/backend2/Architecture MVC.png differ diff --git a/out/diagrams/backend/backend3/Création de vidéo.png b/out/diagrams/backend/backend3/Création de vidéo.png new file mode 100644 index 0000000..862878c Binary files /dev/null and b/out/diagrams/backend/backend3/Création de vidéo.png differ diff --git a/out/diagrams/backend/backend4/Cas d'utilisation.png b/out/diagrams/backend/backend4/Cas d'utilisation.png new file mode 100644 index 0000000..8e3bda6 Binary files /dev/null and b/out/diagrams/backend/backend4/Cas d'utilisation.png differ diff --git a/out/diagrams/backend/backend5/Déploiement.png b/out/diagrams/backend/backend5/Déploiement.png new file mode 100644 index 0000000..5e12a98 Binary files /dev/null and b/out/diagrams/backend/backend5/Déploiement.png differ diff --git a/out/diagrams/frontend/frontend1/frontend1.png b/out/diagrams/frontend/frontend1/frontend1.png new file mode 100644 index 0000000..5429fd4 Binary files /dev/null and b/out/diagrams/frontend/frontend1/frontend1.png differ diff --git a/out/diagrams/frontend/frontend2/frontend2.png b/out/diagrams/frontend/frontend2/frontend2.png new file mode 100644 index 0000000..8cffaf4 Binary files /dev/null and b/out/diagrams/frontend/frontend2/frontend2.png differ diff --git a/out/diagrams/frontend/frontend3/frontend3.png b/out/diagrams/frontend/frontend3/frontend3.png new file mode 100644 index 0000000..e4a6717 Binary files /dev/null and b/out/diagrams/frontend/frontend3/frontend3.png differ diff --git a/out/diagrams/frontend/frontend4/frontend4.png b/out/diagrams/frontend/frontend4/frontend4.png new file mode 100644 index 0000000..5aaa2a0 Binary files /dev/null and b/out/diagrams/frontend/frontend4/frontend4.png differ diff --git a/out/diagrams/frontend/frontend5/frontend5.png b/out/diagrams/frontend/frontend5/frontend5.png new file mode 100644 index 0000000..54eb090 Binary files /dev/null and b/out/diagrams/frontend/frontend5/frontend5.png differ diff --git a/out/diagrams/global/global.png b/out/diagrams/global/global.png new file mode 100644 index 0000000..8bfcce5 Binary files /dev/null and b/out/diagrams/global/global.png differ diff --git a/out/diagrams/global_interspec/global_interspec.png b/out/diagrams/global_interspec/global_interspec.png new file mode 100644 index 0000000..2d49d91 Binary files /dev/null and b/out/diagrams/global_interspec/global_interspec.png differ diff --git a/out/diagrams/global_interspec_lite/global_interspec_lite.png b/out/diagrams/global_interspec_lite/global_interspec_lite.png new file mode 100644 index 0000000..1c8bd19 Binary files /dev/null and b/out/diagrams/global_interspec_lite/global_interspec_lite.png differ diff --git a/out/diagrams/raspi/01_architecture_generale/Architecture Générale du Système Timelapse.png b/out/diagrams/raspi/01_architecture_generale/Architecture Générale du Système Timelapse.png new file mode 100644 index 0000000..028f8fb Binary files /dev/null and b/out/diagrams/raspi/01_architecture_generale/Architecture Générale du Système Timelapse.png differ diff --git a/out/diagrams/raspi/02_flux_capture/Flux du Processus de Capture d'Images.png b/out/diagrams/raspi/02_flux_capture/Flux du Processus de Capture d'Images.png new file mode 100644 index 0000000..dd00eb8 Binary files /dev/null and b/out/diagrams/raspi/02_flux_capture/Flux du Processus de Capture d'Images.png differ diff --git a/out/diagrams/raspi/03_structure_classes/Structure des Classes et Composants.png b/out/diagrams/raspi/03_structure_classes/Structure des Classes et Composants.png new file mode 100644 index 0000000..56dc86b Binary files /dev/null and b/out/diagrams/raspi/03_structure_classes/Structure des Classes et Composants.png differ diff --git a/out/diagrams/raspi/04_sequence_synchronisation/Séquence de Synchronisation des Données.png b/out/diagrams/raspi/04_sequence_synchronisation/Séquence de Synchronisation des Données.png new file mode 100644 index 0000000..49e4feb Binary files /dev/null and b/out/diagrams/raspi/04_sequence_synchronisation/Séquence de Synchronisation des Données.png differ diff --git a/out/diagrams/raspi/05_deploiement_infrastructure/infra_raspi.png b/out/diagrams/raspi/05_deploiement_infrastructure/infra_raspi.png new file mode 100644 index 0000000..bf51e6c Binary files /dev/null and b/out/diagrams/raspi/05_deploiement_infrastructure/infra_raspi.png differ