Pascal × InfraFabric — Embedded Systems Deep Dive (HAE404E)
v2 · dark-default · no-wrappers · IF-1012

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):

Black/white:


Table of contents (mirrors the source docs)


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:


[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:

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:

Pipeline (PROPOSED, mais concrètement implémentable):

  1. Build du firmware (binaire .bin/.elf)
  2. if.trace: publier un reçu pour:
    • le binaire,
    • la config (fréquences, options, defines),
    • un “manifest” (version, target MCU, checksum).
  3. if.gov triage: décider si c’est une release “safe” ou “risquée” (stop conditions: tests manquants, changements ADC/timers, etc).
  4. if.gov council: produire un pack “GO / NO-GO” avec liens vers receipts.
  5. if.bus: émettre un événement firmware.release.approved avec payload_sha256.
  6. if.api: l’adapter “device management” pousse l’update (ou prépare un paquet OTA).
  7. 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:

Pipeline (PROPOSED):

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:

Pipeline (PROPOSED):

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.bus fait 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:

Ê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:

InfraFabric ne te “rend pas invulnérable”. Il te donne un format pour réduire le coût des erreurs:

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):

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):

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à:

Tu n’as pas encore (et c’est normal):

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:


Document A — Microcontrôleurs (Cours HAE404E, 2025)

Table des matières (mirrored)

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):

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:

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:

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:

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:

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)

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)

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)

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:

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)