Refactor code structure for improved readability and maintainability

This commit is contained in:
2025-04-28 00:52:40 +02:00
parent b6e0080caa
commit 93026436a9
48 changed files with 2116 additions and 126 deletions

View File

@@ -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

View File

@@ -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

View File

@@ -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

View File

@@ -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

View File

@@ -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 : <<include>>
UC1 ..> UC8 : <<include>>
UC2 ..> UC7 : <<extend>>
UC2 ..> UC8 : <<extend>>
UC3 ..> UC9 : <<include>>
UC4 ..> UC5 : <<include>>
}
User --> UC1
User --> UC2
User --> UC4
User --> UC5
User --> UC6
Camera --> UC3
Camera --> UC9
@enduml

View File

@@ -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

View File

@@ -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

View File

@@ -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

View File

@@ -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

View File

@@ -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

View File

@@ -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

View File

@@ -1,4 +1,4 @@
@startuml Architecture Globale @startuml global
' Définition des composants ' Définition des composants
node "Interfaces utilisateur" { node "Interfaces utilisateur" {

View File

@@ -0,0 +1,100 @@
@startuml
left to right direction
skinparam component {
BackgroundColor<<Informatique>> #FFE4B5
BackgroundColor<<Électronique>> #98FB98
BackgroundColor<<Matériaux>> #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" <<Informatique>> as server {
component "Backend (Node.js/Express)" as backend
component "FFMPEG Processing" as ffmpeg
component "Base de Données" as db
}
component "Interface Web" <<Informatique>> as web {
component "Frontend (HTML/CSS/JS)" as front
component "Nginx Reverse Proxy" as nginx
}
component "Application Android" <<Informatique>> 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" <<Matériaux>> as box {
component "Structure Étanche" as structure
component "Système Fixation" as mount
}
component "Infrastructure Virtualisée" <<Informatique>> 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

View File

@@ -0,0 +1,87 @@
@startuml
left to right direction
skinparam component {
BackgroundColor<<Logiciel>> #FFE4B5
BackgroundColor<<Matériel>> #98FB98
BackgroundColor<<Infrastructure>> #87CEEB
BorderColor #333
}
package "Matériel" <<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" <<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" <<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
<b>Technologie Matérielle:</b>
• Altium Designer
• STM32 CubeIDE
• I2C/SPI
• RDM6/CES
end note
note bottom of backend
<b>Stack Logicielle:</b>
• Node.js/Express
• FFMPEG
• Auth JWT
• CI/CD Gitea
end note
note left of proxmox
<b>Infrastructure:</b>
• Docker Swarm
• Let's Encrypt
• VPN/Wireguard
• Sauvegardes Automatisées
end note
note top of box
<b>Mécanique:</b>
• Solidworks
• BambuLab X1
• Analyse Thermique
• Classification IP67
end note
@enduml

View File

@@ -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

View File

@@ -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

View File

@@ -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

View File

@@ -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

View File

@@ -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
<b>Infrastructure de Déploiement Timelapse</b>
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

Binary file not shown.

View File

@@ -17,6 +17,7 @@
\usepackage{xcolor} \usepackage{xcolor}
\usepackage{listings} \usepackage{listings}
\usepackage{fancyvrb} \usepackage{fancyvrb}
\usepackage[french]{babel}
% Define the dot-based progress bar % Define the dot-based progress bar
\usepackage{tikz} \usepackage{tikz}
@@ -43,148 +44,35 @@
% Introduction % Introduction
\section{Introduction} \section{Introduction}
\begin{frame}{Contexte et Objectifs} \input{diapos/contexte-objectifs.tex}
\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}
% Cahier des charges % Cahier des charges
\section{Cahier des charges} \section{Cahier des charges}
\begin{frame}{Spécifications et Contraintes} \input{diapos/cahier-charges.tex}
\begin{itemize}
\item Fonctionnalités attendues
\item Contraintes techniques (matériel, logiciel)
\item Livrables
\end{itemize}
\end{frame}
% Partie mécanique % Partie mécanique
\section{Partie mécanique} \section{Partie mécanique}
\begin{frame}{Partie mécanique} \input{diapos/meca.tex}
\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}
% Partie électronique % Partie électronique
\section{Partie électronique} \section{Partie électronique}
\begin{frame}{Partie électronique} \input{diapos/elec.tex}
\begin{itemize}
\item Architecture électronique
\item Composants utilisés (capteurs, microcontrôleurs, etc.)
\item Schémas électroniques
\end{itemize}
\end{frame}
% Partie serveur, front et application mobile % Partie informatique (serveur, front et application mobile)
\section{Serveur, Front et Application mobile} \section{Partie informatique}
\begin{frame}{Serveur, Front et Application mobile} \input{diapos/info.tex}
\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 front end % Partie multimédia
\subsection{Front end} \section{Traitement multimédia}
\begin{frame}{Front end} \input{diapos/multi.tex}
\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}
% Démonstration % Démonstration
\section{Démonstration} \section{Démonstration}
\begin{frame}{Démonstration} \input{diapos/demo.tex}
\begin{itemize}
\item Vidéo ou démonstration en direct du projet
\item Points forts à montrer
\end{itemize}
\end{frame}
% Conclusion % Conclusion
\section{Conclusion} \section{Conclusion}
\begin{frame}{Bilan et perspectives} \input{diapos/conclusion.tex}
\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}
% Remerciements % Remerciements
\begin{frame}{Remerciements} \begin{frame}{Remerciements}

112
diapos/cahier-charges.tex Normal file
View File

@@ -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}

223
diapos/conclusion.tex Normal file
View File

@@ -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}

View File

@@ -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}

97
diapos/demo.tex Normal file
View File

@@ -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}

141
diapos/elec.tex Normal file
View File

@@ -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}

188
diapos/info.tex Normal file
View File

@@ -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}

111
diapos/meca.tex Normal file
View File

@@ -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}

130
diapos/multi.tex Normal file
View File

@@ -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}

Binary file not shown.

After

Width:  |  Height:  |  Size: 44 KiB

Binary file not shown.

After

Width:  |  Height:  |  Size: 96 KiB

Binary file not shown.

After

Width:  |  Height:  |  Size: 55 KiB

Binary file not shown.

After

Width:  |  Height:  |  Size: 74 KiB

Binary file not shown.

After

Width:  |  Height:  |  Size: 43 KiB

Binary file not shown.

After

Width:  |  Height:  |  Size: 48 KiB

Binary file not shown.

After

Width:  |  Height:  |  Size: 40 KiB

Binary file not shown.

After

Width:  |  Height:  |  Size: 16 KiB

Binary file not shown.

After

Width:  |  Height:  |  Size: 25 KiB

Binary file not shown.

After

Width:  |  Height:  |  Size: 37 KiB

Binary file not shown.

After

Width:  |  Height:  |  Size: 22 KiB

Binary file not shown.

After

Width:  |  Height:  |  Size: 25 KiB

Binary file not shown.

After

Width:  |  Height:  |  Size: 142 KiB

Binary file not shown.

After

Width:  |  Height:  |  Size: 119 KiB

Binary file not shown.

After

Width:  |  Height:  |  Size: 57 KiB

Binary file not shown.

After

Width:  |  Height:  |  Size: 90 KiB

Binary file not shown.

After

Width:  |  Height:  |  Size: 102 KiB

Binary file not shown.

After

Width:  |  Height:  |  Size: 71 KiB

Binary file not shown.

After

Width:  |  Height:  |  Size: 91 KiB