Pascal × InfraFabric — Embedded Systems Deep Dive (HAE404E)
Generated (UTC): 2026-02-03T04:14:42Z
Audience: Licence 2 EEA (microcontrôleurs STM32), prof, CTO curieux
Scope: preuves cryptographiques → triage → gouvernance → bus → API (sans mystique, sans bullshit)
Sources (repo-local):
docs/_uploads/JP.tar:JP/cours-HAE404E(1).pdf(Cours “Microcontrôleurs”, Licence 2 EEA / 2025)docs/_uploads/JP.tar:JP/HAE404E-Exam.pdf(Examen TP, joystick analogique, Mai 2025)docs/_uploads/JP.tar:JP/HAE404-ExamTP.pdf(Examen TP, afficheur 7 segments, Mai 2023)docs/_uploads/JP.tar:JP/01_InfraFabric-Productization-Pack-20260201-1814UTC.md(01)docs/_uploads/JP.tar:JP/02_InfraFabric-System-Explainer-20260201-1814UTC.html(02)docs/_uploads/JP.tar:JP/03b_InfraFabric-Regulatory-Spine-20260201-1814UTC.md(03b)docs/_uploads/JP.tar:JP/205-if-bus-2026-01-22-full.md(if.buswhitepaper)docs/_uploads/JP.tar:JP/232-if-api-deep-dive-whitepaper-2026-02-01.md(if.apideep dive)docs/_uploads/JP.tar:JP/218-if-gov-whitepaper-current-and-roadmap.md(if.govwhitepaper)- Writing discipline:
docs/250-if-whitepapers-bible-v2.1-2026-02-02T134443Z.md
Black/white:
- VERIFIED: contenus des PDF ci-dessus + documents InfraFabric listés + concepts explicitement présents dans ces sources.
- PROPOSED: scénarios, analogies, “IF factor” (comment appliquer les modules InfraFabric à un projet embarqué).
- Ce document n’expose aucun secret et n’essaie pas de “prouver la vérité du monde”. Il montre comment prouver les bytes et rendre des décisions auditées.
Table of contents (mirrors the source docs)
- Executive summary (≈4 pages)
- Panel debate (debug → contrarian → synthesis)
- Deep dive
- Document A — Microcontrôleurs (Cours HAE404E, 2025)
- Chapitre I … IX (et sections I.1…IX.6)
- Document B — Examen TP (Joystick analogique, Mai 2025)
- Présentation générale + I.1…I.5
- Document C — Examen TP (Afficheur 7 segments, Mai 2023)
- Présentation générale + I.1…I.5
- Document A — Microcontrôleurs (Cours HAE404E, 2025)
- Appendix
- Glossaire minimal (hash, signature, receipt, envelope, DLQ)
- “Starter kit” de projet perso (prof + CTO)
- References (public URLs, one per line)
Executive summary (≈4 pages)
0) Le “truc” que les gens de ton niveau ne voient pas encore
En L2, on te forme à faire marcher un STM32: GPIO, ADC, PWM, interruptions, SPI/I2C.
Ce que les gens paient (en industrie), c’est quand tu sais faire marcher + prouver + gouverner.
Le différenciateur d’InfraFabric n’est pas “crypto = sécurité”. C’est plus vicieux:
Ce n’est pas “est-ce que c’est signé ?” C’est: “est-ce qu’on peut reconstruire, sans privilèges, qui a publié quoi, quand, pourquoi, et avec quelles limites ?”
Rappel black/white (VERIFIED par les docs 01/03b):
un reçu (if.trace) peut prouver les bytes, pas “la vérité du monde”. La gouvernance (if.gov) sert à rendre les décisions auditées, pas “moralement correctes”.
Dans un système embarqué, le drame ne vient pas d’un bug “GPIO oublié”.
Il vient de: mauvaise version, mauvais binaire, mauvaise config, mauvaise calibration, mauvaise chaîne de décision, mauvaise preuve.
InfraFabric te donne une façon d’industrialiser ça, en couches:
if.trace: reçus d’intégrité (“ces bytes-là existent; voilà le hash”).if.gov: triage + packs de décision (“on a décidé de déployer X parce que…, stop-conditions…, evidence…”).if.bus: enveloppe d’événement + DLQ + contrôle (“ça circule, ça se replay, ça casse proprement”).if.api: frontière d’adaptation (“les bizarreries des fournisseurs restent au bord, pas dans le cœur”).
[bytes] → [if.trace receipt] → [if.gov triage/pack] → [if.bus envelope+DLQ] → [if.api adapters] → [action (device/operator)]
1) Microcontrôleur vs InfraFabric: la métaphore qui claque (et qui est vraie)
Dans le cours HAE404E, tu apprends:
- un CPU parle au monde via des bus (données/adresses),
- les périphériques ont des contrats (registers),
- les interruptions = “événements” (réaction),
- les timers = “cadence” (rythme),
- SPI/I2C = “bus multiplexé” (un maître, plusieurs esclaves).
InfraFabric, c’est exactement la même architecture… mais à l’échelle d’un système logiciel:
STM32 (local) InfraFabric (système)
---------------- ----------------------
Registers + memory map adapter_spec + contracts (if.api)
Interruptions / timers events + routing (if.bus)
Oscilloscope / mesure receipts (hash-bound) (if.trace)
TP noté / décisions d’implémentation triage + decision packs (if.gov)
2) Trois scénarios “embarqués” qui font adulte (et qui sont démontrables)
Scénario A — Mise à jour firmware “preuve-first” (pas juste signé, auditable)
[build .elf/.bin] → [if.trace: hash] → [if.gov: GO/NO-GO] → [if.bus: firmware.release.approved] → [if.api: device mgmt] → [bootloader: verify+flash]
Ancrages HAE404E:
- Chapitre IV (bare-metal vs CMSIS/HAL): tu as déjà la notion “couches d’abstraction”.
- Annexe B/C (flash / reference manual): tu sais que “la flash = vérité matérielle”.
- Chapitre IX (bus multiplexé): tu sais que l’update passe par une chaîne.
Pipeline (PROPOSED, mais concrètement implémentable):
- Build du firmware (binaire
.bin/.elf) if.trace: publier un reçu pour:- le binaire,
- la config (fréquences, options, defines),
- un “manifest” (version, target MCU, checksum).
if.govtriage: décider si c’est une release “safe” ou “risquée” (stop conditions: tests manquants, changements ADC/timers, etc).if.govcouncil: produire un pack “GO / NO-GO” avec liens vers receipts.if.bus: émettre un événementfirmware.release.approvedavecpayload_sha256.if.api: l’adapter “device management” pousse l’update (ou prépare un paquet OTA).- Côté STM32 (ou bootloader): vérifie signature/hash avant flash. Si mismatch → refuse.
La phrase qui tue (CTO-grade, pas marketing):
“Une signature sur un binaire sans reçu ni décision pack, c’est un casque sans jugulaire: ça rassure surtout la personne qui l’a vendu.”
Mini-case: tu déploies 2 versions de firmware “identiques” sauf un prescaler; sans receipts tu disputes, avec receipts tu prouves.
Scénario B — Télémetrie vérifiée (capteurs, ADC, PWM) + DLQ au lieu du chaos
[ADC/I2C sample] → [gateway] → [if.bus envelope] → (OK → workflows) | (BAD → DLQ + reason)
Ancrages HAE404E:
- Chapitre VI (ADC/PWM): la donnée analogique est bruitée, dépend de calibration.
- Chapitre VII (interruptions): les événements arrivent quand ils veulent.
- Chapitre IX (bus multiplexé): tout le monde parle, pas toujours proprement.
Pipeline (PROPOSED):
- L’embarqué produit des mesures (ex: joystick ADC, capteur I2C).
- Une passerelle (Raspberry/PC/STM32+eth) transforme en enveloppes
if.bus:correlation_id,occurred_at,payload_sha256,- métadonnées de calibration (version + receipt
if.tracede la table de calibration).
- Si payload invalide / out-of-range / signature invalide:
- → DLQ (
if.bus.dead_letter_event) au lieu de “on ignore, on espère”.
- → DLQ (
La différence pour un prof (et pour un CTO):
tu ne dis pas “ça marchait chez moi”, tu dis “voilà les bytes, voilà les mesures, voilà les rejets, voilà pourquoi”.
Mini-case: un capteur I2C commence à saturer; l’événement part en DLQ avec raison + payload hash au lieu de disparaître.
Scénario C — Robotique + météo + énergie + compta (le “bus” comme système nerveux)
[robot sensors] + [weather] + [energy] + [accounting] → [if.api adapters] → [if.bus] → [if.gov rules] → [commands/events]
Ancrages HAE404E:
- Chapitre IX (SPI/I2C): le maître arbitre les esclaves.
- Chapitre V (timers): cadence et fenêtres temporelles.
Pipeline (PROPOSED):
- MCU/robot: actionneurs (PWM) + capteurs (I2C/SPI).
- API météo:
if.apiadapter (poll) →if.busevents. - Alimentation/UPS: adapter (SNMP / API) →
if.busevents. - Comptabilité: adapter (CSV/API) →
if.busevents. if.gov: règles de gouvernance:- “si météo annonce vent > X → mode sécurité”,
- “si tension batterie < Y → réduire puissance”,
- “si coût énergie élevé → planification”.
Le concept qui fait mouche:
dans un système multiplexé, ce n’est pas “qui parle le plus fort” qui gagne. C’est le protocole et l’arbitrage.
if.busfait pareil, mais avec des preuves.
Mini-case: la météo déclenche un mode sécurité; tu peux montrer “quel événement a provoqué quel comportement” (pas une narration).
3) Le vrai super-pouvoir: triage (quand tu fais simple vs quand tu fais sérieux)
Tout ne mérite pas une cérémonie.
Le triage if.gov te permet d’être crédible sans être lourd:
- LOW: petits changements → receipts + checklist.
- MED: changement ADC/timers/interruptions → pack + tests.
- HIGH: changement protocole com / bootloader → pack + contrarian + stop conditions.
Être “sécu”, ce n’est pas tout sécuriser. C’est savoir quoi sécuriser quand ça compte.
4) Économie (oui, même en embedded): ce que tu achètes vraiment
Dans un TP, l’échec coûte une note. En industrie, l’échec coûte:
- des heures de debug à l’oscillo (et de “ça marchait hier”),
- des retours terrain (le matériel est déjà loin),
- des appels clients, des mails juridiques, et un CTO qui n’aime plus ton prénom.
InfraFabric ne te “rend pas invulnérable”. Il te donne un format pour réduire le coût des erreurs:
- un bug devient un événement (qui a échoué, où, quand),
- une version devient un artefact prouvable (hash),
- une décision devient un pack (raison + limites + stop conditions),
- une erreur devient une DLQ (rejet explicite), pas un silence.
Traduction cynique: tu transformes le “bruit” en factures que tu peux lire.
5) Psychologie (la partie que tout le monde nie, mais que tout le monde vit)
Les humains ont deux défauts constants:1) Ils confondent “je m’en souviens” avec “c’est vrai”.2) Ils appellent “process” tout ce qui les empêche d’avoir tort en public.
Ce que tu peux démontrer avec un projet InfraFabric (et qui fait adulte):
- tu sais dire non (stop conditions explicites),
- tu sais prouver (bytes + traces),
- tu sais contenir (DLQ + quarantine/replay),
- tu sais être rapide sans mentir (triage).
Si tu veux une punchline présentable:
“Je ne vous demande pas de me faire confiance. Je vous donne les preuves minimales pour que vous puissiez vérifier.”
6) Le format “projet perso” (prof + CTO) qui tient debout
Le projet n’est pas “un firmware qui clignote”. Le projet, c’est:
un système embarqué où chaque changement peut être justifié et rejoué.
Livrables (PROPOSED, mais simples):
- un
workspace.tar.gzcomme dans les examens (B.I.5 / C.I.5), - un firmware binaire + config (hashés),
- un mini “decision pack” (2 pages): ce qui change, risques, comment vérifier,
- un log DLQ (les entrées impossibles; pas de “ça doit être le câblage”).
Tu passes instantanément du niveau “bon élève” au niveau “ingénieur qu’on peut laisser seul”.
Panel debate (debug → contrarian → synthesis)
Format: 4 voix + 1 contrarian (le rôle qui empêche l’auto-hypnose).
Debug: où Pascal en est (VERIFIED à partir des PDFs)
Tu sais déjà:
- C STM32 (GPIO, ADC, PWM, timers, interruptions).
- Lire une doc technique (pins, channels ADC, timers, registers).
- Penser en “sous-ensembles” (architecture par blocs).
- Faire valider par oscilloscope (preuve physique).
Tu n’as pas encore (et c’est normal):
- une “chaîne de preuve” au niveau système (au-delà du scope).
- une gouvernance des changements (au-delà du “TP noté”).
- une approche “bus + DLQ + replay” (au-delà de l’interruption locale).
Panel (dialogue condensé)
Ingénieur embarqué (pragmatique)
“Signer le firmware, c’est déjà bien. Le reste, c’est du process.”
Cryptographe (sec mais pas parano)
“Signer le firmware prouve l’origine, pas la bonne intention, ni la bonne version, ni la bonne config. Sans trace, tu signes aussi tes erreurs.”
Ingénieur automatisme/robotique (terrain)
“Ce qui me tue, c’est l’intégration: météo, énergie, capteurs, maintenance. Le bug arrive dans l’interface entre systèmes.”
CTO (sceptique)
“Je veux de la vitesse. Les packs, c’est du ralentissement.”
Contrarian (anti-bullshit)
“Oui, et si ton système ne vaut pas un audit, il ne vaut pas une industrialisation. Mais attention: trop de gouvernance tue la livraison. Il faut du triage.”
Synthesis (ce qu’on garde)
1) Receipts d’abord (if.trace): coût faible, ROI immédiat.2) Triage (if.gov.triage): décider quand escalader.3) Bus + DLQ (if.bus): transformer la complexité en protocole, pas en panique.4) Adapter boundary (if.api): empêcher les APIs externes de contaminer ton cœur embarqué.
Deep dive (mirrored TOCs + IF factor analysis)
Comment lire cette section
Pour chaque section du cours/exam:
- Résumé (VERIFIED) : ce que la section te fait apprendre.
- IF factor (PROPOSED) : comment tu transformes ça en “système auditable”.
- Mini-case (PROPOSED) : un exemple concret (firmware, messages, capteurs, etc.).
Document A — Microcontrôleurs (Cours HAE404E, 2025)
Table des matières (mirrored)
- Chapitre I — Présentation des Microcontrôleurs
- I.1 Microprocesseur (CPU) ou Microcontrôleur (µP)?
- I.2 Alors, qu’est ce qu’il reste à faire?
- I.3 Choisir un microcontrôleur pour une application
- I.4 Et maintenant?
- Chapitre II — Survol “bas niveau” de la plateforme de travail choisie
- II.1 … II.9
- Chapitre III — Entrées et Sorties “tout-ou-rien”
- III.1 … III.5
- Chapitre IV — Programmer par bibliothèques
- IV.1 … IV.5
- Chapitre V — Gestion du temps et Timers
- V.1 … V.4
- Chapitre VI — Signaux analogiques (ADC/DAC/PWM)
- VI.1 … VI.4
- Chapitre VII — Interruptions externes et périodiques
- VII.1 … VII.5
- Chapitre VIII — Chaîne ADC → traitement → DAC/PWM
- VIII.1 … VIII.5
- Chapitre IX — Communication
- IX.1 … IX.6 (SPI, I2C)
Chapitre I — Présentation des Microcontrôleurs
STM32: [CPU POV] → [périphériques] → [bus]
IF: [if.api spec] → [if.bus envelope] → [if.trace proof] → [if.gov decision]
I.1 Microprocesseur (CPU) ou Microcontrôleur (µP)?
Résumé (VERIFIED): bus, mémoire, périphériques; penser “point de vue CPU”.
IF factor (PROPOSED):
if.api: “point de vue adapter” (les APIs externes sont tes périphériques).if.bus: bus d’événements = “bus d’adresse/données” à l’échelle système.
Mini-case: ton STM32 n’est pas “un script”, c’est un nœud qui émet des événements (capteurs) et reçoit des commandes (mode sécurité).
I.2 Alors, qu’est ce qu’il reste à faire?
Résumé (VERIFIED): environnement concret, contraintes, architecture.
IF factor:
if.gov: formaliser les contraintes comme stop-conditions (pas des post-its).
Mini-case: “si test PWM non vérifié à l’oscillo → release bloquée”.
I.3 Choisir un microcontrôleur pour une application
Résumé (VERIFIED): choix basé sur I/O, bus, mémoire, horloge, coût.
IF factor:
if.api.adapter_spec: même logique pour choisir une API (auth, quotas, payloads, drift).
Mini-case: choisir “météo provider” comme tu choisis un capteur I2C: spec, limites, fallback.
I.4 Et maintenant?
Résumé (VERIFIED): passage à la pratique.
IF factor:
if.trace: commencer par prouver les bytes (builds + configs) avant de “sécuriser”.
Mini-case: premier livrable “adulte” = un binaire + une config + un hash, même si tu n’as encore aucun “process”.
Chapitre II — Survol “bas niveau” de la plateforme STM32
[doc pinout+clocks] → [config] → [mesure/oscillo] → [receipt] → [review]
II.1 Présentation générale
Résumé: contexte STM32 + doc.
IF factor: if.whitepapers.bible = doc discipline similaire: pas de chasse au trésor.Mini-case: écris (et versionne) une mini “fiche carte” (pins, clocks, contraintes) comme tu ferais un pinout annoté.
II.2 L’exemple que nous allons suivre
Résumé: pédagogie par exemple.
IF factor: if.gov = décision par “pack” (exemple complet, auditable).Mini-case: ton “exemple fil rouge” devient un pack: objectif, étapes, limites, et comment vérifier (oscillo).
II.3 Quelles pins utiliser? Explorons la documentation
Résumé: mapping pins/périphériques.
IF factor: if.api = mapping endpoints/capacités (pinout → endpoint map).Mini-case: fais une matrice “pin → fonction → risque” et traite-la comme un artefact (diffable, hashé).
II.4 Ce que nous allons faire maintenant
Résumé: plan d’action.
IF factor: if.gov.triage = choisir le niveau de rigueur avant de coder.Mini-case: tu touches aux timers? → “MED”: tu t’engages à refaire les mesures de période/duty à l’oscillo.
II.5 Un peu d’architecture
Résumé: bus internes, clocks, périphériques.
IF factor: if.bus = architecture “événement + contrôle + DLQ”.Mini-case: liste 5 événements “système” (adc.sampled, pwm.updated, button.pressed…) au lieu de laisser la loop “deviner”.
II.6 Configurer une pin en sortie tout-ou-rien
Résumé: registre, mode, vitesse.
IF factor: “config drift” → if.trace receipt de config + if.gov pack si changement.Mini-case: si tu changes un mode/pull-up, tu publies le diff de config et tu notes l’impact attendu (et ce que tu mesures).
II.7 Piloter une sortie tout-ou-rien
Résumé: set/reset, timing.
IF factor: “commande” = événement if.bus avec corrélation (qui a demandé quoi).Mini-case: une commande “LED ON” doit pouvoir être reliée à une observation “LED ON” (corrélation), sinon tu débogues à l’intuition.
II.8 Le programme complet
Résumé: assemblage initialisation + loop.
IF factor: if.bus runtime = init + loop + DLQ.Mini-case: tu gardes un “boot log” minimal (version + config hash) pour éviter les “mauvaise version flashée”.
II.9 Et maintenant?
Résumé: next steps.
IF factor: “next = prouver” (receipts) + “quand escalader” (triage).Mini-case: ta roadmap n’est pas “on verra”: c’est “quand on touche ADC/timers → on monte en rigueur”.
Chapitre III — E/S “tout-ou-rien”
[câblage] → [GPIO state] → [event] → [policy] → [action] → [preuve]
III.1 LEDs: aspect électronique
Résumé: courant, résistances, contraintes.
IF factor: “le monde physique ment” → conserver preuves de câblage/config (photos + notes → receipts).Mini-case: une photo de câblage + valeurs (R, V) hashées valent mieux qu’un souvenir flou à 3h du matin.
III.2 LEDs: aspect informatique
Résumé: GPIO, mapping ports.
IF factor: if.api: normaliser “inputs hardware” en événements.Mini-case: expose une API interne “led.set(level)” (même basique) au lieu de réécrire du GPIO partout.
III.3 Interrupteur: aspect électronique
Résumé: pull-up/down, rebond.
IF factor: DLQ pour événements “rebond” (détection out-of-policy).Mini-case: tout rebond détecté devient un événement “invalid” (DLQ) au lieu de polluer ton traitement.
III.4 Interrupteur: aspect informatique
Résumé: lecture pin + debouncing.
IF factor: règles if.gov sur “que faire en cas d’entrée instable”.Mini-case: le paramètre de debouncing (ms, seuil) devient un artefact versionné, pas une constante oubliée.
III.5 Programme complet
Résumé: intégration.
IF factor: “intégration = là où on perd la vérité” → receipts + packs.Mini-case: une intégration “ok” se prouve: logs + capture oscillo + hash du workspace.
Chapitre IV — Programmer par bibliothèques
[bare-metal] ↔ [CMSIS/HAL] → [boundary stable] → [dépendances gouvernées (versions+proof)]
IV.1 Bare-metal
Résumé: direct registers.
IF factor: if.api = “bare-metal” des APIs externes (sans magie, tu vois les limites).Mini-case: documente 2–3 registres critiques que tu touches, et attache les valeurs attendues (preuve de compréhension).
IV.2 Bibliothèques pour microcontrôleurs
Résumé: abstraction vs contrôle.
IF factor: adapter_spec = abstraction contrôlée (pas “SDK surprise”).Mini-case: choisis une lib comme tu choisis un périphérique: version pinée, limites connues, fallback.
IV.3 S’abstraire de la Memory Map
Résumé: structures, pointeurs, mapping.
IF factor: l’écosystème devient une “memory map” si tu as des contrats (endpoints) et des receipts (bytes).Mini-case: ton header de mapping (pins/regs) devient un artefact hashé: si ça change, tu le sais.
IV.4 CMSIS + ST Standard Library
Résumé: couches ST, productivité.
IF factor: if.bus + if.api = couches standardisées; tu changes un adapter sans casser le reste.Mini-case: tu changes de couche (bare-metal → CMSIS/HAL)? tu déclenches triage + une passe de tests/mesures.
IV.5 Autres bibliothèques
Résumé: options.
IF factor: gouvernance de dépendances: quelles libs, quelles versions, quels receipts.Mini-case: une dépendance = une surface de dérive; tu la traites comme un fournisseur (spec + pinning + preuve).
Chapitre V — Gestion du temps et Timers
[clock] → [timer tick] → [ISR/work] → [budget/limites] → [retries/backoff] → [audit]
V.1 CPU clock
Résumé: horloges, fréquence, calibration.
IF factor: time = source de disputes → receipts des configs de clock + logs.Mini-case: si la clock change, tes timings changent: tu notes “avant/après” avec une mesure (pas une opinion).
V.2 Principe des Timers
Résumé: comptage, overflow.
IF factor: if.bus a “timers” côté runtime (retries, backoff) → doivent être explicités.Mini-case: un retry sans timer explicite, c’est un timer caché; rends-le visible (et borné).
V.3 Que faire concrètement?
Résumé: config + usage.
IF factor: “quoi faire” devient checklist triage: risque si timing change.Mini-case: “si prescaler modifié → refaire mesure PWM + vérifier interruption 10 ms”.
V.4 Exemple: attendre un temps calibré
Résumé: délais déterministes.
IF factor: idempotency côté API (Stripe/PayPal etc) = “attendre sans doubler l’action”.Mini-case: si ta commande réseau est rejouée (timeout), une clé d’idempotence évite de “flasher/debiter deux fois”.
Chapitre VI — Signaux analogiques (ADC/DAC/PWM)
[monde analogique] → [ADC] → [calibration] → [décision] → [PWM/DAC] → [preuve (oscillo+hash)]
VI.1 ADC
Résumé: conversion, résolution, bruit.
IF factor: preuve de calibration: if.trace pour tables/coeffs + if.gov pour changements.Mini-case: ta table de calibration (coeffs) est hashée et référencée par chaque mesure publiée.
VI.2 DAC
Résumé: sortie analogique.
IF factor: “sortie” = action → doit être traçable (qui a demandé la commande).Mini-case: chaque sortie critique doit avoir un “why”: qui a demandé, selon quelle règle, à quel moment.
VI.3 PWM
Résumé: rapport cyclique, période, perception.
IF factor: “preuve” = oscillo + receipt: tu peux archiver captures + hashes.Mini-case: capture oscillo = preuve; hash-la et lie-la à la version du code qui l’a générée.
VI.4 Comparaison DAC vs PWM
Résumé: tradeoffs.
IF factor: même logique que “polling vs webhook”: choisir selon contraintes et preuve.Mini-case: documente le choix (DAC ou PWM) comme une décision: contraintes, risques, et comment vérifier.
Chapitre VII — Interruptions
[interrupt/event storm] → [mask/quarantine] → [DLQ] → [replay] → [recovery borné]
VII.1 Problème à résoudre
Résumé: réactivité vs loop.
IF factor: if.bus = système d’interruptions distribuées; il faut DLQ pour “interrupt storm”.Mini-case: si ton système génère trop d’événements, tu les mets en quarantaine au lieu de tout casser.
VII.2 Interruption externe
Résumé: événement déclenché.
IF factor: événements if.bus doivent être signés/identifiés (éviter spoof).Mini-case: un capteur “qui ment” doit être détectable (signature/ID), sinon tu débogues une attaque comme un bug.
VII.3 Réalisation STM32L152
Résumé: config NVIC, EXTI.
IF factor: “control plane” (pause/quarantine/replay) = NVIC + masques mais au niveau système.Mini-case: “masquer une interruption” en runtime devient “quarantiner un nœud” sur le bus (sans tuer tout le système).
VII.4 Interruptions périodiques
Résumé: timer interrupt.
IF factor: “pollers” if.api doivent être gouvernés (rate limits).Mini-case: si tu polls une API météo, tu fixes un budget (fréquence) et tu logges les dépassements.
VII.5 Les interruptions sont partout
Résumé: partout, donc risque.
IF factor: triage + budgets (tokens/req/s) pour ne pas exploser.Mini-case: tu mets un budget “events/s” comme tu mets une fréquence d’échantillonnage: sinon, tu satures.
Chapitre VIII — Chaîne ADC → traitement → DAC/PWM
[input ADC] → [transform] → [control output] → [verify] → [receipt] → [replay]
VIII.1 Contexte
Résumé: chaîne complète.
IF factor: c’est exactement la chaîne “adapter → bus → workflow → artifact”.Mini-case: la chaîne ADC→traitement→PWM devient un workflow versionné (inputs, transformations, outputs).
VIII.2 Signaux échantillonnés
Résumé: sampling, aliasing.
IF factor: “sampling” existe aussi en logs/telemetry; receipts évitent la réécriture.Mini-case: tu définis ta fenêtre d’échantillonnage et tu la gardes stable (sinon tu compares des choses incomparables).
VIII.3 Gestion avec microcontrôleur
Résumé: architecture.
IF factor: gouverner “qui a le droit de modifier la chaîne”.Mini-case: seules certaines versions/configs ont le droit de changer la calibration (sinon dérive silencieuse).
VIII.4 Codage PWM de signaux variant
Résumé: modulation dans le temps.
IF factor: dans un système, la “modulation” = backoff/retry; doit être explicitée (pas magique).Mini-case: tes constantes de backoff sont des paramètres versionnés, pas des “sleep(random())”.
VIII.5 DAC ou PWM: la suite!
Résumé: conclusion.
IF factor: décider + prouver + itérer (packs versionnés).Mini-case: une itération “safe” = pack + receipts + une phrase “comment vérifier” (mesure concrète).
Chapitre IX — Communication
[framing] → [ACK] → [DLQ] → [replay] → [audit trail]
IX.1 Liaison série et parallèle
Résumé: coûts, fils, vitesse.
IF factor: “latence vs robustesse” existe aussi entre services; bus standardise.Mini-case: tu choisis UART/SPI/I2C pour des raisons; pareil pour un bus: latence, débit, reprise sur erreur.
IX.2 Synchrone vs asynchrone
Résumé: horloge commune vs événements.
IF factor: if.bus est asynchrone par design; il faut acks (comme I2C).Mini-case: sans ack/retry, tu fais “de l’espoir”; avec ack/DLQ, tu fais de l’ingénierie.
IX.3 Simplex / Full / Half duplex
Résumé: sens de communication.
IF factor: egress (if.api) vs ingress (webhooks) = duplex contrôlé.Mini-case: télémetrie (simplex) ≠ commandes (duplex): tu ne gères pas ces flux avec les mêmes garanties.
IX.4 Bus point à point vs multiplexé
Résumé (VERIFIED): maître/esclaves, sélection, mutualisation.
IF factor:
if.bus= multiplexage explicite des événements + sélection par routage (pas par “qui crie le plus fort”).
Mini-case: plusieurs robots (esclaves) → un orchestrateur (maître) publie commandes; DLQ isole un robot malade.
IX.5 Bus SPI
Résumé: full-duplex + CS.
IF factor: “CS” = corrélation + auth: qui est ciblé par la commande.Mini-case: un device_id dans l’enveloppe, c’est ton “chip select” logiciel: tu sais qui tu commandes.
IX.6 Bus I2C
Résumé: adresses + ACK.
IF factor: ACK = contrôles if.bus.control_ack; sans ACK, tu fais de la magie.Mini-case: un no-ACK devient un événement DLQ explicite; pas un “ça a dû passer”.
Document B — Examen TP (Joystick analogique, Mai 2025)
[joystick PA3/PA5] → [ADC1 CH3/CH5] → [mapping] → [PWM PB6/PB7] → [timer ISR 10ms] → [proof pack]
TOC (mirrored)
- Présentation générale (joystick = 2 potentiomètres, ADC1 CH3/CH5)
- I.1 Version 0 (seuil 60% → LED PB6)
- I.2 Version 1 (PB6 vertical + PB7 horizontal)
- I.3 Version 2 (PWM proportionnel, période 0.1 ms)
- I.4 Version 3 (timer interrupt 10 ms, main vide)
- I.5 Rendre la copie (workspace archive)
IF factor (appliqué au TP)
Présentation générale
Résumé: tu mesures un monde analogique, tu décides une action (LED).
IF factor: preuve de config ADC + calibration (receipt) + logs.Mini-case: produis un seul “sample event” JSON/CBOR avec x/y + hash de la config ADC (preuve de provenance).
I.1 Version 0
Résumé: seuil + GPIO.
IF factor: baseline = “LOW triage”: receipts (code + pinmap) suffisent.Mini-case: le seuil (60%) devient un paramètre versionné; tu évites le “on a changé un truc”.
I.2 Version 1
Résumé: deux axes, logique de coins.
IF factor: “table de vérité” devient un artefact: tu peux la versionner et la prouver.Mini-case: la table “coins → LEDs” est un fichier (ou commentaire) hashé, pas une logique implicite.
I.3 Version 2
Résumé: PWM proportionnel + oscillo.
IF factor: capture oscillo = evidence; hash + receipt; c’est ton “unit test” physique.Mini-case: tu attaches une capture de période/duty à la version du code; pas besoin d’argumenter.
I.4 Version 3
Résumé: architecture événementielle (interrupt timer).
IF factor: tu viens d’inventer if.bus en miniature: loop vide, événements font le boulot; ajoute DLQ pour valeurs impossibles.Mini-case: l’interruption 10 ms devient ton “scheduler”; tu logges tout dépassement de budget (trop long) comme anomalie.
I.5 Rendre la copie
Résumé: archive + transmission.
IF factor: “archive” = pack; if.trace transforme ça en preuve vérifiable.Mini-case: ton workspace.tar.gz devient un artefact “signable”: tu peux prouver exactement ce que tu as rendu.
Mini-case (PROPOSED, project perso): joystick → commande d’un robot via bus; tout événement porte un hash; relecture possible.
Document C — Examen TP (Afficheur 7 segments, Mai 2023)
[segments a..g] → [GPIO/PWM TIM3+TIM4] → [logique d'affichage] → [vérif duty/période] → [pack+receipt]
TOC (mirrored)
- Présentation générale (cathode commune, segments a..g)
- I.1 Version 0 (allumer tout)
- I.2 Version 1 (compte à rebours 3→0)
- I.3 Version 2 (PWM PB7/8/9, période 1.5 ms, duty 30%)
- I.4 Version 3 (PWM partout, même période/duty)
- I.5 Rendre la copie (archive)
IF factor (appliqué au TP)
Présentation générale
Résumé: mapping segments ↔ pins ↔ timers ↔ channels.
IF factor: c’est un adapter_spec matériel (endpoints = pins; rate = PWM; contraintes = courant).Mini-case: écris le mapping a..g → (port,pin,timer,ch) comme une spec (et garde-la stable entre versions).
I.1 Version 0
Résumé: smoke test câblage.
IF factor: un “smoke test” doit être prouvé: photo + notes + receipt.Mini-case: photo + “toutes LEDs ON” + hash = preuve que le problème (si) n’est pas le câblage.
I.2 Version 1
Résumé: logique d’affichage + délais.
IF factor: le délai “à la main” est un risque; triage te pousse vers timers (comme dans le cours).Mini-case: si tu utilises des boucles de délai, tu notes “qualité limitée”; si tu passes timers, tu gagnes en preuve.
I.3 Version 2
Résumé: PWM vérifié oscillo.
IF factor: evidence capture; et surtout: contrat (période/duty) au lieu de “ça clignote pas”.Mini-case: tu ne dis pas “ça ne clignote pas”: tu dis “1.5 ms / 30% mesuré”, capture à l’appui.
I.4 Version 3
Résumé: généralisation PWM (architecture).
IF factor: systématiser l’abstraction: la même logique que “normaliser les APIs” (if.api).Mini-case: tu factorises “set_segment_intensity(letter, duty)” comme un adapter; le reste du code devient stable.
I.5 Rendre la copie
Résumé: pack de rendu.
IF factor: receipts + decision pack = ton projet devient auditable.Mini-case: tu peux rejouer la démo à partir de l’archive + du pack (sans compter sur ta mémoire).
Appendix A — Glossaire minimal (pas de poésie, juste utile)
- Hash (sha256): empreinte d’un contenu. Si un bit change, le hash change.
- Signature: preuve qu’une clé privée a approuvé un contenu (authenticité + intégrité).
- **Receipt (
if.trace)**: preuve “ces bytes-là existent” + hash publié; ce n’est pas une preuve de vérité. - **Envelope (
if.bus)**: message standard (métadonnées + payload hash + routage). - DLQ: “dead letter queue”: messages rejetés (invalides) stockés avec raison, au lieu d’être perdus.
- **Triage (
if.gov)**: décider le niveau de rigueur, avant d’ouvrir le robinet.
Appendix B — Starter kit (projet perso présentable prof + CTO)
Objectif: un mini-système embarqué auditable.
1) Un STM32 fait une mesure ADC (joystick) et une action PWM (LED).2) Une passerelle (PC/RPi) reçoit la mesure via série/SPI/I2C et émet un événement structuré.3) Tu publies:
- code + binaire + config (receipts),
- un mini “decision pack” (pourquoi cette version),
- un log DLQ (valeurs invalides / hors calibration).
Tu as alors un projet qui se présente ainsi:
“Je peux prouver ce que mon système a exécuté, et expliquer pourquoi, sans que vous me fassiez confiance.”
Appendix C — References (public URLs, one per line)
- https://infrafabric.io
- https://infrafabric.io/llm/
- https://infrafabric.io/if/trace/
- https://infrafabric.io/llm/if.registry.json.txt
- https://infrafabric.io/llm/entrypoint.json.txt
- https://infrafabric.io/llm/sot/index.json.txt
- https://infrafabric.io/llm/products/if-api/deep-dive/2026-02-01-v1.0.1/index.md.txt
- https://infrafabric.io/llm/products/if-bus/full-stack-whitepaper/2026-01-22/index.md.txt
- https://infrafabric.io/llm/products/if-gov/