Illustre les modules 0 à 2 (9 figures)

Bibliothèque commune schemas/outils.py (boîtes, flèches, chronogrammes, séquences). M0 : chaîne de développement, séquence BOOT/RESET. M1 : architecture, comparatif Uno/ESP32-S3, diviseur de tension. M2 : pull-up, rebonds, chenillard, protocole WS2812.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

schemas/outils.py

@@ -0,0 +1,129 @@
+"""Briques graphiques communes : toile de dessin, boîtes, flèches, chronogrammes, séquences."""
+import matplotlib.pyplot as plt
+from matplotlib.patches import FancyBboxPatch
+
+from style import BLEU, CM, ENCRE, GRIS, GRIS_CLAIR
+
+CLAIR = {  # fonds pâles associés aux couleurs de la charte
+    BLEU: "#e8f0fe", "#e07a1f": "#fdf0e3", "#2e8b57": "#e6f4ea",
+    "#c0392b": "#fce8e6", GRIS: "#f3f4f6",
+}
+
+
+def toile(largeur_cm, hauteur_cm, xmax=None, ymax=None):
+    """Figure sans axes, en coordonnées « cm » (1 unité = 1 cm à l'échelle d'origine)."""
+    fig, ax = plt.subplots(figsize=(largeur_cm * CM, hauteur_cm * CM))
+    ax.set_xlim(0, xmax or largeur_cm)
+    ax.set_ylim(0, ymax or hauteur_cm)
+    ax.set_aspect("equal")
+    ax.axis("off")
+    return fig, ax
+
+
+def boite(ax, x, y, l, h, texte="", couleur=BLEU, taille=9, gras=False, fond=None, style="round", alpha=1):
+    """Boîte arrondie centrée sur (x, y). Renvoie un dict des points d'ancrage."""
+    fond = fond if fond is not None else CLAIR.get(couleur, "white")
+    ax.add_patch(FancyBboxPatch((x - l / 2, y - h / 2), l, h,
+                                boxstyle=f"{style},pad=0,rounding_size=0.15" if style == "round" else style,
+                                facecolor=fond, edgecolor=couleur, linewidth=1.4, alpha=alpha))
+    if texte:
+        ax.text(x, y, texte, ha="center", va="center", fontsize=taille, color=ENCRE,
+                fontweight="bold" if gras else "normal", linespacing=1.3)
+    return {"c": (x, y), "g": (x - l / 2, y), "d": (x + l / 2, y),
+            "h": (x, y + h / 2), "b": (x, y - h / 2)}
+
+
+def fleche(ax, depart, arrivee, texte="", couleur=ENCRE, taille=8, double=False, pointille=False,
+           cote="haut", decalage=0.18, courbe=0):
+    """Flèche entre deux points, avec étiquette optionnelle au milieu."""
+    ax.annotate("", xy=arrivee, xytext=depart,
+                arrowprops=dict(arrowstyle="<|-|>" if double else "-|>", color=couleur, lw=1.3,
+                                linestyle="--" if pointille else "-", shrinkA=0, shrinkB=0,
+                                mutation_scale=11, connectionstyle=f"arc3,rad={courbe}"))
+    if texte:
+        mx, my = (depart[0] + arrivee[0]) / 2, (depart[1] + arrivee[1]) / 2
+        vertical = abs(arrivee[0] - depart[0]) < abs(arrivee[1] - depart[1])
+        if vertical:
+            ax.text(mx + decalage, my, texte, ha="left", va="center", fontsize=taille, color=couleur)
+        else:
+            dy = decalage if cote == "haut" else -decalage
+            ax.text(mx, my + dy, texte, ha="center", va="bottom" if cote == "haut" else "top",
+                    fontsize=taille, color=couleur)
+
+
+def chronogramme(voies, duree, largeur_cm=16, hauteur_voie_cm=1.5, graduations=None, unite="",
+                 couleurs=None):
+    """Chronogramme logique.
+
+    voies : liste de (nom, [(t, niveau), ...]) — niveau 0/1, maintenu jusqu'au point suivant.
+    Renvoie (fig, ax, y_voie) où y_voie(i) donne l'ordonnée de base de la voie i.
+    """
+    n = len(voies)
+    fig, ax = plt.subplots(figsize=(largeur_cm * CM, (n * hauteur_voie_cm + 1.2) * CM))
+    ax.set_xlim(-duree * 0.02, duree * 1.01)
+    ax.set_ylim(-0.6, n * 1.6)
+    ax.spines[["left", "top", "right"]].set_visible(False)
+    ax.set_yticks([])
+    ax.grid(axis="y", visible=False)
+    if graduations is not None:
+        ax.set_xticks(graduations)
+    if unite:
+        ax.set_xlabel(unite)
+    y_voie = lambda i: (n - 1 - i) * 1.6
+    for i, (nom, points) in enumerate(voies):
+        base = y_voie(i)
+        xs, ys = [], []
+        for k, (t, niv) in enumerate(points):
+            fin = points[k + 1][0] if k + 1 < len(points) else duree
+            xs += [t, fin]
+            ys += [base + niv, base + niv]
+        c = (couleurs or {}).get(nom, BLEU)
+        ax.plot(xs, ys, color=c, lw=1.8, solid_joinstyle="miter")
+        ax.fill_between(xs, base, ys, color=c, alpha=0.08)
+        ax.text(-duree * 0.025, base + 0.5, nom, ha="right", va="center", fontsize=9,
+                color=ENCRE, fontweight="bold")
+    return fig, ax, y_voie
+
+
+def sequence(acteurs, messages, largeur_cm=16, pas_cm=0.85, couleurs=None, notes=()):
+    """Diagramme de séquence.
+
+    acteurs : liste de noms. messages : liste de (source, cible, texte[, pointillé]).
+    notes : liste de (index_message, acteur, texte) affichées à droite de la ligne de vie.
+    """
+    n = len(messages)
+    hauteur = n * pas_cm + 2.2
+    fig, ax = toile(largeur_cm, hauteur)
+    xs = {a: largeur_cm * (i + 0.5) / len(acteurs) for i, a in enumerate(acteurs)}
+    haut = hauteur - 0.6
+    for a, x in xs.items():
+        c = (couleurs or {}).get(a, BLEU)
+        boite(ax, x, haut, min(3.6, largeur_cm / len(acteurs) - 0.4), 0.8, a, couleur=c, taille=8.5, gras=True)
+        ax.plot([x, x], [0.3, haut - 0.4], color=GRIS, lw=1, ls=(0, (3, 3)))
+    for k, msg in enumerate(messages):
+        src, dst, texte = msg[:3]
+        pointille = len(msg) > 3 and msg[3]
+        y = haut - 1.2 - k * pas_cm
+        if src == dst:
+            ax.annotate("", xy=(xs[src] + 0.05, y - 0.3), xytext=(xs[src] + 0.05, y),
+                        arrowprops=dict(arrowstyle="-|>", color=ENCRE, lw=1.1,
+                                        connectionstyle="arc,angleA=0,angleB=0,armA=18,armB=18,rad=4",
+                                        mutation_scale=9))
+            ax.text(xs[src] + 0.75, y - 0.15, texte, fontsize=7.8, va="center", color=ENCRE)
+            continue
+        fleche(ax, (xs[src], y), (xs[dst], y), texte, pointille=pointille, taille=7.8, decalage=0.08)
+    for k, acteur, texte in notes:
+        y = haut - 1.2 - k * pas_cm
+        ax.text(xs[acteur] + 0.2, y, texte, fontsize=7.5, color=GRIS, style="italic", va="center")
+    return fig, ax
+
+
+def legende_couleurs(ax, elements, x, y, taille=7.5):
+    """Petite légende manuelle : elements = [(couleur, texte), ...]."""
+    for i, (c, t) in enumerate(elements):
+        ax.add_patch(plt.Rectangle((x, y - i * 0.45 - 0.12), 0.35, 0.25, color=c))
+        ax.text(x + 0.5, y - i * 0.45, t, fontsize=taille, va="center", color=ENCRE)
+
+
+__all__ = ["toile", "boite", "fleche", "chronogramme", "sequence", "legende_couleurs",
+           "CLAIR", "GRIS_CLAIR"]