Le decalage d'horloge etait fausse de deux heures par mon propre parseur

Le module ecrit une heure de mur LOCALE. Je l'interpretais comme de
l'UTC, ce qui ajoutait exactement le decalage de Paris a chaque
decalage deduit : d'ou les +7 h 27 et +9 h 59 qui semblaient absurdes
et qui, corriges, tombent sur les valeurs mesurees au chronometre.

La deduction redevient donc fiable, et chaque export voit desormais
son dernier enregistrement atterrir sur l'heure de l'export lui-meme.
Les valeurs mesurees restent en commentaire pour controler la
deduction, pas pour la remplacer.

--remplacer efface les lignes du module avant de reinserer : corriger
un decalage AJOUTAIT sinon une seconde copie decalee, la cle primaire
portant l'instant.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01KKzkkVTG6KXnGXFFC7X9XJ

tools/importer-cellules.mjs

@@ -27,6 +27,20 @@ const motifs = args.filter((a) => !a.startsWith('--'));
 // Correspondance adresse -> code-barres pour les CSV de suivi, qui ne portent
 // que l'adresse. Chaque chaine renumerote a partir de 1 : une adresse seule
 // est ambigue dans ce parc. Completer au fil des relevés `info <n>`.
+// Decalage d'horloge MESURE au chronometre, par module, en minutes. Ces
+// valeurs viennent de la lecture directe du RTC face a l'horloge du poste, le
+// 05/09/2026 — pas d'une deduction. Chaque module a son propre RTC.
+//
+//   chaine du pack ancien, `pwr` a 12:16 -> RTC 18:07:52   =>  +5 h 52
+//   module isole (…0324),  `time` a 12:47 -> RTC 18:56:35  =>  +6 h 09
+//   chaine du pack recent, `pwr` a 12:23 -> RTC 18:36:33   =>  +6 h 13
+//
+// La deduction automatique se trompait de 1 h 30 a 4 h : le tampon du BMS est
+// circulaire et contient des enregistrements anterieurs a des remises a
+// l'heure, donc le plus recent des horodatages n'est pas fiable.
+// Repere : ces valeurs ont ete mesurees au chronometre le 05/09/2026 et
+// servent a CONTROLER la deduction, pas a la remplacer.
+//   pack ancien +5 h 52  ·  module isole +6 h 09  ·  pack recent +6 h 13
 const CARTE_SUIVI = {
   1: 'K220803C30160322',   // pack ancien, adresse 1
   3: 'K220803C30160319',   // pack ancien, adresse 3
@@ -52,8 +66,13 @@ function lireHistorique(f) {
     const [a, m, j] = c[1].split('-').map(Number);
     const [H, M, S] = c[2].split(':').map(Number);
     recs.set(+c[0], {
-      // heure MODULE, corrigee plus bas
-      brut: Date.UTC(2000 + a, m - 1, j, H, M, S),
+      // Heure MODULE, corrigee plus bas. Le module ecrit une heure de mur
+      // LOCALE : il faut l'interpreter comme telle, jamais comme de l'UTC.
+      // Le faire ajoutait exactement le decalage de Paris (2 h en ete) a
+      // chaque decalage d'horloge deduit — d'ou les « +7 h 27 » et « +9 h 59 »
+      // qui semblaient absurdes et qui, corriges, tombent sur les valeurs
+      // mesurees au chronometre.
+      brut: new Date(2000 + a, m - 1, j, H, M, S).getTime(),
       courant: +c[4], soc: parseInt(c[16], 10), etat: c[10],
       mv: Array.from({ length: 15 }, (_, k) => +c[18 + k * 6 + 1]),
     });
@@ -92,11 +111,9 @@ function lireHistorique(f) {
   const lignes = [];
   for (const r of rangs) {
     const x = recs.get(r);
-    // Le module ecrit en heure locale de Paris : on repasse par l'offset reel.
     const t = new Date(x.brut - decalageMs);
-    const local = new Date(t.getTime() - new Date(t).getTimezoneOffset() * 60000);
     for (let k = 0; k < 15; k++) {
-      lignes.push([local.toISOString(), bc[1], k + 1, x.mv[k], x.soc, x.courant, x.etat, 'historique']);
+      lignes.push([t.toISOString(), bc[1], k + 1, x.mv[k], x.soc, x.courant, x.etat, 'historique']);
     }
   }
   return { module: bc[1], decalageMin, origine, lignes, nb: rangs.length };
@@ -168,6 +185,17 @@ const client = new pg.Client({
   password: process.env.PGPASSWORD,
 });
 await client.connect();
+// --remplacer : effacer d'abord les lignes des modules concernes pour la meme
+// source. Sans cela, corriger un decalage d'horloge AJOUTE une seconde copie
+// decalee au lieu de remplacer la premiere — la cle primaire porte l'instant.
+if (args.includes('--remplacer')) {
+  const paires = [...new Set(toutes.map((l) => l[1] + '\u0000' + l[7]))]
+    .map((x) => x.split('\u0000'));
+  for (const [mod, src] of paires) {
+    const r = await client.query('DELETE FROM cellule WHERE module = $1 AND source = $2', [mod, src]);
+    console.log(`  efface ${r.rowCount} lignes de ${mod} (${src})`);
+  }
+}
 let ecrites = 0;
 for (let i = 0; i < toutes.length; i += 500) {
   const lot = toutes.slice(i, i + 500);