# Mode vitrine : une matrice qui tourne toute seule

Dans la vitrine, personne ne tapera de commande. Il faut que le Pi :

1. **démarre le lecteur tout seul** quand on l'allume ;
2. permette de **changer les animations** facilement ;
3. **survive aux coupures de courant** (une vitrine est souvent éteinte le
   soir par un interrupteur général) ;
4. respecte des **horaires**, si besoin.

Ce guide suppose que l'installation est faite ([INSTALLATION_PI.md](INSTALLATION_PI.md))
et que `lecteur.py` fonctionne quand on le lance à la main.

---

## Sommaire

1. [Démarrage automatique](#1-démarrage-automatique)
2. [Surveiller et arrêter le lecteur](#2-surveiller-et-arrêter-le-lecteur)
3. [Changer les animations](#3-changer-les-animations)
4. [Survivre aux coupures de courant](#4-survivre-aux-coupures-de-courant)
5. [Horaires d'allumage](#5-horaires-dallumage)
6. [Alimentation et installation définitive](#6-alimentation-et-installation-définitive)
7. [Entretien et sauvegarde](#7-entretien-et-sauvegarde)
8. [En cas de panne dans la vitrine](#8-en-cas-de-panne-dans-la-vitrine)

---

## 1. Démarrage automatique

L'installation a préparé un **service** nommé `vitrine-pixels` : un programme
que Linux lance tout seul à chaque démarrage, et **relance s'il s'arrête**
(erreur, fichier abîmé…). Son fichier modèle :
[`installation/vitrine-pixels.service`](installation/vitrine-pixels.service).

Pour l'**activer** (une seule fois) :

```bash
sudo systemctl enable --now vitrine-pixels
```

`enable` = démarrer à chaque allumage ; `--now` = et aussi tout de suite.
Débranchez et rebranchez le Pi : environ **30 secondes** après, les
animations démarrent.

Pour le **désactiver** (retour au lancement à la main) :

```bash
sudo systemctl disable --now vitrine-pixels
```

---

## 2. Surveiller et arrêter le lecteur

| Je veux… | Commande |
|---|---|
| savoir si le lecteur tourne | `systemctl status vitrine-pixels` (`active (running)` = oui ; **q** pour quitter) |
| savoir si l'interface web tourne | `systemctl status vitrine-web` |
| voir ce qu'il affiche, en direct | `journalctl -u vitrine-pixels -f` (**Ctrl + C** pour quitter) |
| l'arrêter jusqu'au prochain démarrage | `sudo systemctl stop vitrine-pixels` |
| le relancer (après avoir modifié un réglage) | `sudo systemctl restart vitrine-pixels` |

> ⚠️ **Un seul programme à la fois** peut parler à la matrice. Avant de lancer
> `test_matrice.py`, `mes_animations.py` ou `lecteur.py` à la main, **arrêtez
> le service** (`sudo systemctl stop vitrine-pixels`), sinon les deux
> programmes se battent et la matrice affiche n'importe quoi.

---

## 3. Changer les animations

Le lecteur lit le dossier **`/boot/firmware/animations`** (ou
**`/boot/animations`** sur les systèmes plus anciens comme Raspbian 11). Ce dossier se trouve
sur la petite partie de la carte SD nommée **`bootfs`** (**`boot`** sur les
systèmes plus anciens), formatée en FAT32 :
le format des clés USB, que **Windows, macOS et Linux** savent tous lire et
écrire. C'est pour ça qu'on l'a choisi.

Le dossier est **relu à chaque tour de boucle** : pas besoin de redémarrer
le lecteur après un changement.

### Méthode 0 : la page web (la plus simple)

Ouvrez l'adresse du Pi dans un navigateur : `http://172.16.50.27` depuis le
Wi-Fi, `http://172.16.7.199` depuis le réseau filaire (voir
[INTERFACE_WEB.md, partie 1](INTERFACE_WEB.md#1-ouvrir-la-page)) : on y dépose les animations, on choisit celles qui sont jouées
et leur ordre. Tout est expliqué dans [INTERFACE_WEB.md](INTERFACE_WEB.md).
Les méthodes suivantes servent quand il n'y a pas de réseau.

### Méthode 1 : la carte SD (sans réseau, sans terminal)

C'est la méthode à donner à l'équipe design.

1. Éteignez le Pi **proprement** : `sudo poweroff` en SSH, ou… si le Pi est
   protégé par l'*overlay* (partie 4), on peut simplement couper le courant.
2. Retirez la carte micro-SD du Pi et mettez-la dans l'ordinateur.
3. Un lecteur nommé **`bootfs`** apparaît. Ouvrez le dossier **`animations`**.
4. Ajoutez, supprimez ou renommez des animations (voir
   [GUIDE_KRITA.md, partie 8](GUIDE_KRITA.md#8-déposer-lanimation)).
   ⚠️ **Ne touchez à rien d'autre** sur `bootfs` : ce sont les fichiers de
   démarrage du Pi.
5. **Éjectez** la carte proprement (clic droit → Éjecter), remettez-la dans
   le Pi, rallumez.

> **Windows propose de « formater » la carte ?** C'est l'autre partie de la
> carte (le système Linux), que Windows ne sait pas lire. Répondez
> **Annuler**, jamais Formater !

> **macOS** crée des fichiers cachés (`._coeur.gif`, `.DS_Store`) : le
> lecteur les ignore, pas d'inquiétude.

### Méthode 2 : par le réseau

Depuis l'ordinateur, sur le même Wi-Fi que le Pi. Le dossier appartient à
l'administrateur : on copie d'abord dans le dossier personnel, puis on
déplace avec `sudo`.

```bash
scp -r 05_feu_de_camp 06_logo.png pixel@vitrine.local:~/
```

Puis, dans une session SSH sur le Pi :

```bash
sudo mv ~/05_feu_de_camp ~/06_logo.png /boot/firmware/animations/
```

Pour voir ce qu'il y a dans le dossier :

```bash
ls /boot/firmware/animations
```

Pour retirer une animation :

```bash
sudo rm -r /boot/firmware/animations/05_feu_de_camp
```

> Cette méthode ne marche que si la partition `bootfs` n'est **pas protégée
> en écriture** (partie 4).

---

## 4. Survivre aux coupures de courant

### Le problème

Une carte SD n'aime pas qu'on lui coupe le courant **pendant qu'elle écrit**.
Or Linux écrit régulièrement sur la carte (journaux, fichiers temporaires…).
Une coupure au mauvais moment peut abîmer des fichiers, et un jour le Pi ne
redémarre plus. Pour un ordinateur qu'on éteint proprement, aucun souci ;
pour une vitrine coupée chaque soir à l'interrupteur, c'est une question de
semaines.

### La solution : l'« overlay » (système en lecture seule)

Raspberry Pi OS sait rendre la carte SD **intouchable** : toutes les écritures
vont dans la mémoire vive (la RAM), et disparaissent à l'extinction. La carte
SD n'est plus jamais modifiée : on peut couper le courant n'importe quand.

C'est comme une **ardoise magique** posée sur la carte : on peut écrire
dessus, mais tout s'efface au redémarrage.

**Pour l'activer**, en SSH :

```bash
sudo raspi-config
```

1. Avec les flèches : **Performance Options** → **Overlay File System**.
2. « Would you like the overlay file system to be enabled? » → **Oui**.
3. « Would you like the boot partition to be write-protected? » :
   - **Oui** (conseillé pour la vitrine) : protection totale ; on change
     alors les animations par la **méthode 1** (carte SD dans l'ordinateur),
     qui fonctionne toujours ;
   - **Non** : la méthode 2 (réseau) reste possible.
4. **Finish**, puis redémarrer.

### ⚠️ Le piège de l'ardoise magique

Avec l'overlay activé, **toute modification faite sur le Pi est perdue au
redémarrage** : un réglage changé dans `matrice.py`, un fichier copié dans
`~/vitrine`… Pour modifier durablement quelque chose :

1. `sudo raspi-config` → désactiver l'Overlay File System → redémarrer ;
2. faire ses modifications, tester ;
3. réactiver l'overlay → redémarrer.

**Règle simple** : on règle tout (orientation, luminosité, horaires) **avant**
d'activer l'overlay, au moment de l'installation dans la vitrine.

---

## 5. Horaires d'allumage

Deux façons de faire :

### A. Une prise programmable (conseillé)

Une **prise minuteur** (mécanique ou numérique, quelques euros) coupe le
courant du Pi **et** de l'alimentation des LED la nuit. Simple, fiable,
économe : la nuit, rien ne consomme. **Il faut alors l'overlay** (partie 4),
puisque le courant est coupé brutalement chaque soir.

### B. Le réglage `HORAIRES` du lecteur

En haut de [`lecteur.py`](lecteur.py) :

```python
HORAIRES = ("09:00", "22:30")
```

En dehors de ces heures, la matrice s'éteint (le Pi, lui, reste allumé).
Les horaires qui passent minuit fonctionnent : `("18:00", "02:00")`.

> ⚠️ **Le Pi n'a pas d'horloge à pile** (sauf le Pi 5). Il met son heure à
> jour **par Internet** au démarrage. Sans réseau dans la vitrine, son heure
> est fausse et les horaires ne marchent pas. Dans ce cas : prise
> programmable.

---

## 6. Alimentation et installation définitive

L'alimentation d'établi, c'est pour l'atelier. Dans la vitrine :

- **Alimentation 5 V fixe** pour les LED, d'au moins **5 A** pour la matrice
  8 × 32 à luminosité modérée, **10 A** pour la matrice finale 7 × 39. Préférez
  un **bloc secteur fermé** (comme un chargeur d'ordinateur, avec une prise
  jack) à une alimentation « nue » à vis : sur ces dernières, le 230 V est
  accessible.
  ⚠️ **Tout câblage en 230 V doit être fait ou vérifié par une personne
  compétente.**
- Réglez `COURANT_MAX_MA` dans `matrice.py` à environ **80 %** de ce que
  fournit l'alimentation (4000 pour un bloc de 5 A).
- **Luminosité** : en vitrine, en plein jour, il faut souvent monter
  `LUMINOSITE` à 100, voire 150. Regardez depuis la rue, à différentes heures.
  Plus de luminosité = plus de courant : vérifiez avec `verifier_animation.py`.
- **Fils** : remplacez la plaque d'essai par une **plaque à pastilles soudée**
  (ou au minimum, collez les fils au pistolet à colle) : les vibrations et les
  manipulations finissent toujours par débrancher un fil Dupont.
- **Chaleur** : derrière une vitre au soleil, il peut faire plus de 50 °C.
  Laissez de l'air autour du Pi et de l'alimentation. Pour voir la
  température du Pi : `vcgencmd measure_temp` (au-delà de 80 °C, il ralentit).
- **Wi-Fi** : si la vitrine a du Wi-Fi, on peut garder un accès SSH pour
  dépanner à distance. Sinon, la méthode « carte SD » suffit.

---

## 7. Entretien et sauvegarde

- **Gardez une carte SD de secours** prête, identique à celle de la vitrine
  (même installation). En cas de panne, on échange les cartes en une minute.
- **Gardez une copie des animations** ailleurs que sur la carte SD (sur un
  ordinateur ou un disque partagé de l'équipe).
- Pour faire une **copie exacte** d'une carte SD (une « image ») : logiciels
  **Win32 Disk Imager** (Windows), **ApplePi-Baker** (macOS), ou la commande
  `dd` (Linux). On peut ensuite réécrire cette image sur une nouvelle carte
  avec Raspberry Pi Imager (*Use custom*).

---

## 8. En cas de panne dans la vitrine

| Symptôme | Vérifier | Solution |
|---|---|---|
| Rien ne s'allume du tout | La LED rouge du Pi est-elle allumée ? | Prise, prise programmable, bloc secteur du Pi |
| | L'alimentation des LED est-elle branchée ? | La puce 74AHCT125 est alimentée par elle : sans elle, aucun signal |
| Le Pi est allumé mais la matrice reste noire | Le service tourne-t-il ? `systemctl status vitrine-pixels` | `sudo systemctl restart vitrine-pixels` ; lire le journal (partie 2) |
| | Les horaires sont-ils corrects ? L'heure du Pi est-elle bonne ? (`date`) | Corriger `HORAIRES` ou mettre `None` |
| | Le dossier d'animations est-il vide ? | Un point bleu-vert qui respire en bas à droite = « je n'ai rien à jouer » |
| Une animation est sautée | Journal : `✗ impossible de lire ce fichier` | Réexporter le fichier depuis Krita |
| Les nouvelles animations n'apparaissent pas | Ont-elles été copiées dans `bootfs/animations` (et pas ailleurs) ? | Refaire la copie, éjecter proprement la carte |
| | Overlay activé et copie faite par le réseau ? | Avec l'overlay, la copie réseau est perdue au redémarrage : passer par la carte SD |
| Le Pi ne démarre plus (LED verte immobile) | Carte SD abîmée | Remettre la carte de secours ; refaire une carte (et activer l'overlay !) |
| Couleurs aléatoires après un transport | Un fil s'est débranché ou desserré | Revoir le montage avec le [README](README.md#6-brancher-étape-par-étape) |