Lucas/mkdocs-smarteye/docs/deploiement/jetson-expert.md

# Installation du Jetson SmartEye

## Philosophie : le Jetson est une Box

Le Jetson SmartEye se deploie comme une box internet (Free, Orange). L'installateur arrive chez le beneficiaire avec le boitier pre-configure, le branche sur le reseau local, et **tout se passe depuis son smartphone**. Aucun ecran, aucun clavier, aucun cable HDMI.

```mermaid
graph LR
    subgraph Domicile["Domicile du beneficiaire"]
        BOX["Jetson SmartEye"]
        CAM1["Camera 1"]
        CAM2["Camera 2"]
        CAM3["Camera 3"]
        ROUTER["Box Internet"]
        BOX ---|Ethernet| ROUTER
        CAM1 ---|WiFi/Ethernet| ROUTER
        CAM2 ---|WiFi/Ethernet| ROUTER
        CAM3 ---|WiFi/Ethernet| ROUTER
    end

    subgraph Install["Smartphone installateur"]
        APP["LucasApp / Navigateur"]
    end

    ROUTER ---|WiFi| APP
    APP -.->|"http://smarteye.local:8080"| BOX
```

## Materiel necessaire

| Element | Detail |
|---------|--------|
| **Jetson Orin Nano** | Avec SmartEye pre-installe sur carte SD |
| **Alimentation** | USB-C 5V/3A (fournie) |
| **Cable Ethernet** | RJ45, branchement sur la box internet du client |
| **Cameras IP** | CTronic ou compatible ONVIF, deja installees |
| **Smartphone** | Android ou iOS, connecte au meme reseau WiFi |

---

## Etape 1 : Branchement physique

1. **Brancher le cable Ethernet** du Jetson a la box internet du client
2. **Brancher l'alimentation USB-C** du Jetson
3. **Attendre 60 secondes** — le Jetson demarre et se connecte au reseau local

!!! info "LED de statut"
    Le Jetson n'a pas d'ecran mais dispose d'une LED verte :

    - **Clignotement lent** : demarrage en cours
    - **Fixe** : connecte au reseau, pret pour la configuration
    - **Clignotement rapide** : surveillance active, tout fonctionne

---

## Etape 2 : Decouverte sur le reseau local

Le Jetson annonce automatiquement sa presence sur le reseau local via **mDNS (Avahi/Bonjour)**. Depuis le smartphone connecte au meme WiFi :

### Option A : Acces direct (recommande)

Ouvrir un navigateur et aller a :

```
http://smarteye.local:8080
```

!!! tip "Si smarteye.local ne repond pas"
    Certaines box internet bloquent le mDNS. Dans ce cas, utiliser l'option B.

### Option B : Scan reseau depuis LucasApp

1. Ouvrir **LucasApp** sur le smartphone
2. Aller dans **Parametres > Installer un SmartEye**
3. L'application scanne le reseau local (plage 192.168.x.x)
4. Le Jetson apparait dans la liste des appareils detectes
5. Appuyer dessus pour ouvrir l'interface de configuration

```mermaid
sequenceDiagram
    participant Phone as Smartphone
    participant Jetson as Jetson SmartEye
    participant Router as Box Internet

    Phone->>Router: Scan reseau local (UDP broadcast)
    Router-->>Phone: Liste des appareils
    Phone->>Jetson: GET /api/identity (port 8080)
    Jetson-->>Phone: {"type": "smarteye", "version": "v30", "status": "setup"}
    Phone->>Phone: Affiche "SmartEye detecte"
```

### Option C : QR Code sur le boitier

Un QR code colle sur le Jetson contient son adresse MAC. LucasApp peut scanner ce QR code pour identifier le bon appareil sur le reseau.

---

## Etape 3 : Interface de configuration (WebUI)

L'interface web du Jetson s'affiche sur le smartphone. L'installation se fait en **4 sous-etapes** guidees.

### 3.1 — Identification du site

| Champ | Description | Exemple |
|-------|-------------|---------|
| **ID Client** | Identifiant du beneficiaire (fourni par Lucas) | `dupont_marie` |
| **Token** | Jeton d'authentification (fourni par Lucas) | `b5ce5015` |
| **Nom du site** | Nom lisible | `Residence Dupont` |

!!! warning "Ou trouver l'ID et le Token ?"
    L'ID client et le token sont generes lors de la creation du dossier dans l'interface d'administration Lucas ([admin.php](https://lucas.unigest.fr/admin.php)). Voir le [Guide nouveau client](../guide/nouveau-client.md).

### 3.2 — Detection automatique des cameras (ONVIF)

Le Jetson scanne le reseau local a la recherche de cameras compatibles ONVIF.

```
Scan en cours...

Camera detectee : 192.168.1.143 (CTronic - Salon)
Camera detectee : 192.168.1.148 (CTronic - Chambre)
Camera detectee : 192.168.1.152 (CTronic - Cuisine)

3 cameras trouvees.
```

Pour chaque camera detectee :

| Champ | Auto-detecte | Modifiable |
|-------|:------------:|:----------:|
| **Adresse IP** | Oui | Oui |
| **Nom** (piece) | Non | Oui |
| **Login RTSP** | Non | Oui |
| **Mot de passe RTSP** | Non | Oui |
| **Flux HD** (/11) | Oui | Oui |
| **Flux SD** (/12) | Oui | Oui |
| **Active** | Oui | Oui |

!!! tip "Verifier le flux en direct"
    Appuyer sur **Tester** a cote de chaque camera pour afficher un apercu en direct sur le smartphone. Cela confirme que les identifiants RTSP sont corrects.

### 3.3 — Connexion au serveur Lucas

Le Jetson doit etablir une connexion securisee (tunnel SSH) vers le serveur OVH.

| Parametre | Valeur par defaut | Modifiable |
|-----------|-------------------|:----------:|
| **Serveur** | `57.128.74.87` | Oui |
| **Utilisateur SSH** | `debian` | Oui |
| **Domaine** | `lucas.unigest.fr` | Oui |
| **Numero de site** | Auto (prochain disponible) | Oui |

```mermaid
sequenceDiagram
    participant Jetson
    participant OVH as Serveur OVH

    Jetson->>OVH: Test connexion SSH
    OVH-->>Jetson: OK - Cle autorisee
    Jetson->>OVH: Ouverture tunnels RTSP (ports 8560-8565)
    Jetson->>OVH: Ouverture tunnel Audio (port 8566)
    Jetson->>OVH: POST api.php (test image)
    OVH-->>Jetson: 200 OK - Client reconnu
    Jetson-->>Jetson: Connexion validee
```

!!! note "Attribution automatique des ports"
    Le Jetson calcule automatiquement sa plage de ports selon la convention :

    ```
    Site N → base_port = 8550 + (N-1) x 10

    Ports attribues :
      base+0 a base+5 : RTSP cameras (max 6)
      base+6           : Audio WebSocket
      base+7           : WebUI locale
      base+8 a base+9  : Reserves
    ```

    Exemple pour le site n°2 : ports 8560 a 8569.

### 3.4 — Test de bout en bout

Le Jetson effectue un test complet de la chaine :

```
[1/5] Connexion cameras RTSP............ OK
[2/5] Detection IA (YOLO)............... OK (personne detectee)
[3/5] Tunnel SSH vers OVH............... OK
[4/5] Envoi image test a api.php........ OK (Gemini: "RAS")
[5/5] Notification push Firebase........ OK (recue sur LucasApp)

=== INSTALLATION TERMINEE ===
SmartEye est operationnel.
La surveillance demarre automatiquement.
```

!!! success "Installation terminee"
    Une fois le test valide, le Jetson passe en mode **surveillance active**. Il demarre automatiquement a chaque mise sous tension, sans aucune intervention.

---

## Etape 4 : Verification depuis LucasApp

Sur le smartphone de chaque aidant :

1. Ouvrir **LucasApp**
2. Verifier que le flux video en direct est accessible
3. Verifier que l'interphone fonctionne (audio bidirectionnel)
4. Effectuer un **test de chute simule** :
    - Se coucher au sol dans le champ d'une camera
    - Attendre ~30 secondes
    - Verifier la reception de la notification push
    - Verifier l'image et le message Gemini dans l'alerte

---

## Architecture reseau complete

```mermaid
graph TB
    subgraph Domicile["Domicile du beneficiaire"]
        CAM1["Camera 1<br/>192.168.1.143"]
        CAM2["Camera 2<br/>192.168.1.148"]
        CAM3["Camera 3<br/>192.168.1.152"]
        JETSON["Jetson SmartEye<br/>192.168.1.xxx"]
        ROUTER["Box Internet<br/>192.168.1.1"]

        CAM1 -->|RTSP local| JETSON
        CAM2 -->|RTSP local| JETSON
        CAM3 -->|RTSP local| JETSON
        JETSON ---|Ethernet| ROUTER
    end

    subgraph OVH["Serveur OVH (57.128.74.87)"]
        SSH["SSH Gateway"]
        RTSP_RELAY["Relay RTSP<br/>ports 8560-8565"]
        AUDIO["Audio WebSocket<br/>port 8566"]
        API["api.php"]
        GEMINI["Gemini 2.5 Flash"]
        FCM["Firebase Cloud Messaging"]
    end

    JETSON ==>|"SSH Tunnel (autossh)<br/>Persistant, auto-reconnect"| SSH
    SSH --> RTSP_RELAY
    SSH --> AUDIO
    JETSON ==>|"POST image<br/>si chute detectee"| API
    API --> GEMINI
    GEMINI --> FCM

    subgraph Aidants["Smartphones aidants"]
        APP1["LucasApp - Fille"]
        APP2["LucasApp - Fils"]
    end

    FCM ==>|Push notification| APP1
    FCM ==>|Push notification| APP2
    RTSP_RELAY -.->|"Flux video live"| APP1
    AUDIO -.->|"Interphone"| APP1
```

---

## Fichier de configuration genere

A la fin de l'installation, le Jetson cree automatiquement le fichier `smarteye_config.yaml` :

```yaml
# Genere automatiquement par l'assistant d'installation
# Ne pas modifier manuellement sauf si necessaire

site:
  id: "dupont_marie"
  name: "Residence Dupont"
  client_token: "b5ce5015"

server:
  api_url: "https://lucas.unigest.fr/api.php"
  ovh_ip: "57.128.74.87"
  ssh_user: "debian"

ports:
  site_number: 2
  base_port: 8560

cameras:
  - id: "Cam1"
    name: "Salon"
    ip: "192.168.1.143"
    username: "admin"
    password: "********"
    stream_hd: "/11"
    stream_sd: "/12"
    tunnel_port: 8560
    enabled: true

  - id: "Cam2"
    name: "Chambre"
    ip: "192.168.1.148"
    username: "admin"
    password: "********"
    stream_hd: "/11"
    stream_sd: "/12"
    tunnel_port: 8561
    enabled: true

  - id: "Cam3"
    name: "Cuisine"
    ip: "192.168.1.152"
    username: "admin"
    password: "********"
    stream_hd: "/11"
    stream_sd: "/12"
    tunnel_port: 8562
    enabled: true

audio:
  local_port: 8800
  tunnel_port: 8566

detection:
  yolo:
    std_confidence: 0.15
    pose_confidence: 0.25
  alert_interval: 120
```

---

## Maintenance et acces distant

Une fois installe, le Jetson est accessible a distance depuis le serveur OVH via le tunnel SSH inverse :

```bash
# Depuis le serveur OVH, acceder au WebUI du Jetson
# (tunnel inverse sur le port base+7)
curl http://localhost:8567/api/status
```

### Commandes utiles (pour le support technique)

| Action | Commande |
|--------|----------|
| **Statut du Jetson** | `curl http://localhost:<base+7>/api/status` |
| **Redemarrer SmartEye** | `ssh -p <tunnel> jetson "sudo systemctl restart smarteye"` |
| **Voir les logs** | `ssh -p <tunnel> jetson "journalctl -u smarteye -f"` |
| **Mettre a jour** | `ssh -p <tunnel> jetson "cd /w && git pull && sudo systemctl restart smarteye"` |

!!! warning "Resilience reseau"
    Le service `autossh` maintient les tunnels SSH en permanence. En cas de coupure internet :

    - Les tunnels se retablissent automatiquement a la reconnexion
    - SmartEye continue la detection localement meme sans internet
    - Les alertes en attente sont envoyees des que la connexion revient

---

## Resume du flux d'installation

```mermaid
graph TD
    A["Branchement Ethernet + USB-C"] --> B["Demarrage automatique (60s)"]
    B --> C["Annonce mDNS sur le reseau local"]
    C --> D{"Smartphone detecte le Jetson"}
    D -->|"smarteye.local:8080"| E["WebUI de configuration"]
    D -->|"LucasApp scan"| E
    D -->|"QR Code"| E
    E --> F["Saisie ID client + Token"]
    F --> G["Scan ONVIF des cameras"]
    G --> H["Configuration des cameras"]
    H --> I["Connexion SSH vers OVH"]
    I --> J["Test de bout en bout"]
    J -->|"Tout OK"| K["Surveillance active"]
    J -->|"Echec"| L["Diagnostic et correction"]
    L --> J

    style A fill:#455a64,color:#fff
    style K fill:#00695c,color:#fff
    style L fill:#bf360c,color:#fff
```