Update evaluation subproject to latest commit

.forgejo/workflows/demo.yaml

@@ -1,20 +0,0 @@
-on:
-  push:
-    branches:
-      - "main"
-jobs:
-  test:
-    runs-on: self-hosted
-    steps:
-      - name: Checkout repository
-        uses: actions/checkout@v4
-      - name: Initialize virtual environment
-        run: /usr/bin/python -m venv .env
-      - name: Install dependencies
-        run: ./.env/bin/pip install mystmd
-      - name: Build static HTML
-        run: ./.env/bin/myst build --html
-      - name: Copy files
-        run: |
-          rm -rf /data/srv/forgejo-runner/cours4.0
-          cp -r _build/html /data/srv/forgejo-runner/cours4.0

.forgejo/workflows/serve.yaml

@@ -0,0 +1,29 @@
+on:
+  push:
+    tags:
+      - 'v*'
+jobs:
+  serve:
+    runs-on: myst
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+        with:
+          submodules: "true"
+          token: ${{ secrets.FORGEJO_TOKEN }}
+      - name: Execute code
+        run: uv run myst build --execute
+      - name: Build PDF exports
+        run: uv run myst build --execute --pdf
+      - name: Build static HTML
+        run: |
+          uv run myst build --execute --html
+          mkdir -p /tmp/release
+          cd _build/html
+          zip -r /tmp/release/html.zip .
+      - name: Make release
+        uses: actions/forgejo-release@v2.6.0
+        with:
+          direction: upload
+          release-dir: /tmp/release
+          token: ${{ secrets.FORGEJO_TOKEN }}

.gitmodules

@@ -0,0 +1,6 @@
+[submodule "courstex"]
+	path = courstex
+	url = https://code.edgarpierre.fr/lps/courstex.git
+[submodule "evaluation"]
+	path = evaluation
+	url = https://code.edgarpierre.fr/lps/evaluation4.0.git

.python-version

@@ -0,0 +1 @@
+3.13

README.md

@@ -1,3 +1,7 @@
 # Cours 4.0
 
-[![Made with MyST](https://img.shields.io/badge/made%20with-myst-orange)](https://myst.tools)
+<https://cours.edgarpierre.fr>
+
+[![Made with MyST](https://img.shields.io/badge/made%20with-myst-orange?style=for-the-badge&logo=jupyter)](https://myst.tools)
+[![Forgejo Actions](https://code.edgarpierre.fr/edpibu/cours4.0/badges/workflows/serve.yaml/badge.svg?style=for-the-badge&label=build)](https://code.edgarpierre.fr/edpibu/cours4.0/actions?workflow=serve.yaml)
+[![Release](https://code.edgarpierre.fr/edpibu/cours4.0/badges/release.svg?style=for-the-badge&label=)](https://code.edgarpierre.fr/edpibu/cours4.0/releases/latest)

cours/BTS MS/TP/01-pneumatique.md

@@ -0,0 +1,92 @@
+---
+title: Étude du système pneumatique de la SAM-B
+subject: TP
+export:
+  - format: pdf
+    template: courstex
+date: 2025-05-09
+---
+
+# Introduction
+L'objectif de cette activité est d'étudier le système pneumatique de la SAM-B afin d'en comprendre le fonctionnement et d'être capable d'expliquer les choix qui ont été réalisé pour les différents composants.
+
+# Étude des actionneurs
+
+1. À l'aide du schéma pneumatique, identifier les actionneurs pneumatiques présents sur la SAM-B.
+
+_On s'intéresse dans un premier temps uniquement aux vérins._
+
+2. Pour chacun des vérins de la SAM-B, indiquer ses principales caractéristiques.
+
+:::{hint} Conseil
+:class: dropdown
+Les principales caractéristiques d'un vérin sont :
+- son type (simple effet, double effet),
+- sa course,
+- le diamètre de son piston,
+- le diamètre de sa tige.
+:::
+
+3. Relever la pression d'alimentation nominale de la SAM-B. Déterminer la force exercée par les vérins en phase sortante.
+
+:::{hint} Conseil
+:class: dropdown
+Pour calculer l'effort exercé par un vérin, on calcule $F=P\cdot{}S$, où $F$ est la force exercée, $P$ la pression et $S$ la surface du piston.
+:::
+
+4. Pour les vérins double effet, déterminer la force exercée par les vérins en phase entrante.
+
+:::{hint} Conseil
+:class: dropdown
+En phase entrante, il faut penser à retrancher la section de la tige du vérin à la surface du piston.
+:::
+
+5. Retrouver sur le [site d'Emerson](https://www.emerson.com/fr-fr) la documentation technique des différents vérins présents. Vérifier les résultats obtenus jusqu'à présent.
+
+6. Comparer la force de retour des différents vérins, et justifier l'utilisation qui est faite de chaque type de vérin dans la SAM-B.
+
+_On s'intéresse désormais au vibrateur de la SAM-B._
+
+7. Rappeler le rôle du vibrateur dans le fonctionnement de la SAM-B.
+
+8. Retrouver sur le [site de Netter](https://www.nettervibration.com/) la documentation technique du vibrateur de la SAM-B. Indiquer ses principales caractéristiques.
+
+:::{hint} Conseil
+:class: dropdown
+Les principales caractéristiques d'un vibrateur sont :
+- sa fréquence nominale,
+- la force centrifuge générée,
+- la consommation d'air,
+- le niveau sonore.
+:::
+
+# Distribution pneumatique
+
+9. Retrouver sur le [site d'Emerson](https://www.emerson.com/fr-fr) la documentation technique des distributeurs utilisés sur la SAM-B. Déterminer le débit maximal permis par ces distributeurs.
+
+10. Justifier le choix du distributeur vis-à-vis des besoins de la SAM-B.
+
+# Maintenance du système pneumatique
+
+11. À partir des documentations fournies par les fabricants, établir un tableau récapitulatif de la maintenance à réaliser sur le système pneumatique de la SAM-B.
+
+# Détermination du débit d'air
+
+12. Déterminer le volume des différents vérins présents sur la SAM-B.
+
+Une même quantité de gaz circulant dans un circuit pneumatique occupe un volume différent selon sa pression. Pour quantifier cela, on utilise l'unité du normo mètre cube (Nm{sup}`3`), qui représente le volume qu'occuperait cette quantité de gaz à une température de 15°C à pression atmosphérique (1013.25 hPa).
+
+Pour passer des mètres cubes aux normo mètres cubes, on utilise la formule suivante :
+$$
+V' = V\cdot{}\frac{P_\text{abs}}{P_\text{ref}}\cdot{}\frac{T_\text{ref}}{T}
+$$
+
+13. Déterminer la quantité d'air nécessaire pour déplacer les différents vérins à la pression de service en Nm{sup}`3`.
+
+14. Déterminer la quantité d'air consommée pendant un cycle par la SAM-B (sans activation du vibrateur).
+
+15. Lancer un cycle machine. Déterminer la durée du cycle. En utilisant les données du compteur d'air, déterminer la quantité d'air consommée par la machine durant un cycle.
+
+16. Déterminer le débit d'air moyen consommé par la machine en production.
+
+17. Sélectionner un compresseur parmi la gamme [Atlas Copco GA VSD{sup}`s`](https://www.atlascopco.com/fr-fr/compressors/products/air-compressor/rotary-screw-compressor/ga-vsds-series).

cours/SIN/01-capteurs.md

@@ -0,0 +1,103 @@
+---
+title: Les capteurs
+subject: Cours
+export:
+  - format: pdf
+    template: courstex
+---
+
+# Définition
+
+:::{prf:definition} Capteur
+:nonumber: true
+Appareil sensible à un phénomène physique, qu’il transforme en un signal,
+généralement électrique, transmissible à distance.
+
+[Dictionnaire de l’Académie française, 9e édition](https://dictionnaire-academie.fr/article/A9C0681)
+:::
+
+En d'autres termes, un capteur permet de convertir une grandeur physique (telle
+que la pression, la température, le courant électrique, etc.) en signal plus
+facile à exploiter (généralement un signal électrique). Il réalise la fonction
+**Acquérir** de la chaîne d'information.
+
+On distingue habituellement trois types de capteurs : les capteurs Tout ou Rien
+(TOR), les capteurs Analogiques et les capteurs Numériques.
+
+# Les différents types de capteurs
+## Les capteurs Tout Ou Rien
+Les capteurs Tout ou Rien ne peuvent générer en sortie que deux valeurs : tout ou rien.
+Ils génèrent donc un signal dit **binaire**.
+Un interrupteur (@inter) ou un détecteur de mouvement PIR (@pir) sont des capteurs
+tout ou rien.
+
+:::{figure} https://upload.wikimedia.org/wikipedia/commons/3/3a/Switches-electrical.agr.jpg 
+:label: inter
+:width: 50%
+
+Interrupteur[^inter].
+
+[^inter]: [en:User:ArnoldReinhold](https://commons.wikimedia.org/wiki/File:Switches-electrical.agr.jpg),
+[CC BY-SA 3.0](http://creativecommons.org/licenses/by-sa/3.0/), via Wikimedia Commons
+:::
+
+:::{figure} https://upload.wikimedia.org/wikipedia/commons/2/2e/Motion_detector.jpg
+:label: pir
+:width: 50%
+
+Détecteur de mouvement PIR[^pir].
+
+[^pir]: [CHG](https://commons.wikimedia.org/wiki/File:Motion_detector.jpg),
+Public domain, via Wikimedia Commons.
+:::
+
+## Les capteurs analogiques
+Le signal de sortie est en relation directe avec la grandeur d'entrée
+(généralement proportionnelle)
+Le signal de sortie peut prendre différentes valeurs de manière continue,
+c'est un signal dit **analogique**.
+Une thermistance (@thermistance) ou une jauge de déformation (@jauge) sont des
+capteurs analogiques.
+
+:::{figure} https://upload.wikimedia.org/wikipedia/commons/3/3b/NTC_bead.jpg
+:label: thermistance
+:width: 50%
+
+Thermistance : résistance variant selon la température[^thermistance].
+
+[^thermistance]: [Ansgar Hellwig](https://commons.wikimedia.org/wiki/File:NTC_bead.jpg),
+[CC BY-SA 2.0 DE](https://creativecommons.org/licenses/by-sa/2.0/de/deed.en),
+via Wikimedia Commons.
+:::
+
+:::{figure} https://upload.wikimedia.org/wikipedia/commons/0/0a/Unmounted_strain_gauge.jpg
+:label: jauge
+:width: 50%
+
+Jauge de déformation : résistance variant selon son élongation[^jauge].
+
+[^jauge]: [Pleriche](https://commons.wikimedia.org/wiki/File:Unmounted_strain_gauge.jpg),
+[CC BY-SA 4.0](https://creativecommons.org/licenses/by-sa/4.0), via Wikimedia Commons.
+:::
+
+## Les capteurs numériques
+Un capteur numérique génère un signal de sortie ne pouvant prendre qu'un certain nombre de valeur distincte, c'est à dire un signal **numérique**.
+Une caméra (@camera) ou un codeur absolu (@codeur) sont des capteurs numériques.
+
+:::{figure} https://upload.wikimedia.org/wikipedia/commons/0/02/S4000_Image_Sensor_%28Colorful%29.jpg
+:label: camera
+:width: 50%
+
+Caméra : pour chaque pixel, le signal peut prendre une valeur entière allant de 0 à 255[^camera].
+
+[^camera]: [Glosome](https://commons.wikimedia.org/wiki/File:S4000_Image_Sensor_(Colorful).jpg), [CC BY-SA 4.0](https://creativecommons.org/licenses/by-sa/4.0), via Wikimedia Commons
+:::
+:::{figure} https://upload.wikimedia.org/wikipedia/commons/a/a8/Gray_code_rotary_encoder_13-track_opened.jpg
+:label: codeur
+:width: 50%
+
+Codeur absolu : le signal prend une valeur entière différente selon l'angle du disque[^codeur].
+
+[^codeur]: [Mike1024](https://commons.wikimedia.org/wiki/File:Gray_code_rotary_encoder_13-track_opened.jpg),
+Public domain, via Wikimedia Commons
+:::

cours/SIN/02-signaux.md

@@ -0,0 +1,143 @@
+---
+title: Les signaux
+subject: Cours
+export:
+  - format: pdf
+    template: courstex
+kernelspec:
+  name: python3
+  display_name: Python 3
+---
+
+# Définition
+
+:::{prf:definition} Signal
+:nonumber: true
+Phénomène ou grandeur physique variables dans le temps, donnant une information
+sur l’état du système qui les produit et que peut détecter un capteur.
+
+[Dictionnaire de l’Académie française, 9e édition](https://dictionnaire-academie.fr/article/A9S1603)
+:::
+
+En d'autres termes, un signal est une grandeur physique (tension, courant,
+pression, etc.) variable qui transporte une information.
+
+Les flux de la chaîne d'information sont des signaux. On retrouve généralement
+en sortie du bloc _Acquérir_ un signal électrique.
+
+# Les différents types de signaux
+
+## Les signaux logiques
+Un signal logique ne peut prendre que deux valeurs : un niveau **haut** ("High")
+et un niveau **bas** ("Low").
+
+````{figure}
+:label: fig:sig-logique
+```{code-cell} python
+:tags: [remove-input]
+import matplotlib.pyplot as plt
+from matplotlib import ticker
+import numpy as np
+
+rng = np.random.default_rng(25)
+
+n = 16
+t = np.arange(n+1)
+s = rng.choice([0, 1], n)
+
+fig, ax = plt.subplots()
+ax.stairs(s, t, lw=3, baseline=None)
+ax.set(
+  xlim=(0, n),
+  ylim=(-.5, 1.5),
+  xlabel="Temps (s)",
+  ylabel="Signal logique",
+)
+ax.yaxis.set_major_locator(ticker.MultipleLocator(1))
+ax.xaxis.set_major_locator(ticker.MultipleLocator(1))
+```
+Exemple de signal logique
+````
+
+Le signal logique en @fig:sig-logique est par exemple à l'état haut entre 2 s et 3 s,
+et à l'état bas entre 3 s et 6 s.
+Lorsque le signal passe de l'état bas à l'état haut (comme à 2 s),
+on parle de **front montant**.
+Dans le cas contraire (comme à 3 s), on parle de **front descendant**.
+
+## Les signaux analogiques
+
+Un signal analogique est un signal qui peut prendre un ensemble continu de valeurs.
+Un exemple de signal analogique est donné en @fig:sig-analogique.
+
+````{figure}
+:label: fig:sig-analogique
+```{code-cell} python
+:tags: [remove-input]
+import matplotlib.pyplot as plt
+from matplotlib import ticker
+import numpy as np
+from scipy.interpolate import CubicSpline
+from scipy.stats import qmc
+
+
+rng = np.random.default_rng(25)
+
+n = 20
+t_max = 16
+
+t_base = np.linspace(0, t_max, n)
+lhs = (qmc.LatinHypercube(d=n-2, rng=rng).random(1)[0] - .5) * t_max/n
+t = t_base + np.concatenate(([0], lhs, [0]))
+t = t_base
+s = 5 * rng.random(n)
+
+t_interp = np.linspace(0, t_max, 1024)
+s_interp = np.clip(CubicSpline(t, s)(t_interp), 0, 5)
+
+fig, ax = plt.subplots()
+ax.plot(t_interp, s_interp, lw=3)
+ax.set(
+  xlim=(0, t_max),
+  ylim=(-.5, 5.5),
+  xlabel="Temps (s)",
+  ylabel="Signal analogique",
+)
+ax.yaxis.set_major_locator(ticker.MultipleLocator(1))
+ax.xaxis.set_major_locator(ticker.MultipleLocator(1))
+```
+Exemple de signal analogique
+````
+
+## Les signaux numériques
+Un signal numérique est un signal qui peut prendre un ensemble discret de valeur,
+c'est-à-dire un ensemble précis de valeurs distinctes (généralement des nombres entiers).
+Un exemple de signal analogique est donné en @fig:sig-numerique.
+
+````{figure}
+:label: fig:sig-numerique
+```{code-cell} python
+:tags: [remove-input]
+import matplotlib.pyplot as plt
+from matplotlib import ticker
+import numpy as np
+
+rng = np.random.default_rng(25)
+
+n = 16
+t = np.arange(n+1)
+s = rng.integers(0, 16, n)
+
+fig, ax = plt.subplots()
+ax.stairs(s, t, lw=3, baseline=None)
+ax.set(
+  xlim=(0, n),
+  ylim=(-.5, 16.5),
+  xlabel="Temps (s)",
+  ylabel="Signal numérique",
+)
+ax.yaxis.set_major_locator(ticker.MultipleLocator(1))
+ax.xaxis.set_major_locator(ticker.MultipleLocator(1))
+```
+Exemple de signal numérique
+````

cours/SIN/03-can.md

@@ -0,0 +1,139 @@
+---
+title: Le CAN
+subject: Cours
+export:
+  - format: pdf
+    template: courstex
+kernelspec:
+  name: python3
+  display_name: Python 3
+abbreviations:
+  CAN: Convertisseur Analogique Numérique
+---
+
+# Définition
+
+:::{prf:definition} CAN
+:nonumber: true
+Un convertisseur analogique-numérique est un dispositif électronique dont la fonction est de traduire une grandeur analogique en une valeur numérique codée sur plusieurs bits. Le signal converti est généralement une tension électrique.
+
+Source : Article _[Convertisseur analogique-numérique](http://fr.wikipedia.org/wiki/Convertisseur_analogique-num%C3%A9rique)_ de [Wikipédia en français](https://fr.wikipedia.org/) ([auteurs](http://fr.wikipedia.org/w/index.php?title=Convertisseur_analogique-num%C3%A9rique&action=history))
+:::
+
+# L'échantillonage du signal
+L'échantillonage du signal est la prise d'une valeur à un intervalle régulier de temps. L'intervalle entre deux valeurs s'appelle **période d'échantillonage**. On la note $T_e$ (en secondes). On parle aussi de **fréquence d'échantillonage** $f_e=\frac{1}{T_e}$ (en Hertz), qui correspond au nombre de valeurs prises chaque seconde.
+
+Le **quantum** correspond au plus petit écart quantifiable (la "hauteur d'une marche"). On le note $q$ et son unité est celle du signal d'entrée (généralement le Volt).
+
+La **tension de pleine échelle** ou **tension de référence** est la tension maximale quantifiable par le CAN. On la note $V_\text{pe}$ ou $V_\text{ref}$.
+
+Le nombre de valeurs que peut générer le convertisseur se note $N$ et dépend du nombre de bits $n$ du convertisseur. Ainsi : $N=2^n$.
+
+On obtient la relation suivante : $q=\frac{V_\text{pe}}{N}=\frac{V_\text{pe}}{2^n}$.
+
+# Exemple de conversion
+On donne en @fig:exemple-can l'exemple d'un CAN de tension de référence 5 V fonctionnant sur 3 bits avec une fréquence d'échantillonage de 2 Hz.
+
+La **caractéristique** du CAN est la courbe représentant la valeur numérique en sortie en fonction de la valeur analogique en entrée (@fig:carac-can).
+
+::::{figure}
+:label: fig:exemple-can
+:::{code-cell} python
+:tags: [remove-input]
+import matplotlib.pyplot as plt
+from matplotlib import ticker
+import numpy as np
+from scipy.interpolate import CubicSpline
+from scipy.stats import qmc
+
+rng = np.random.default_rng(50)
+
+n = 20
+t_max = 8
+n_interp = t_max * 100 + 1
+
+t_base = np.linspace(0, t_max, n)
+lhs = (qmc.LatinHypercube(d=n-2, rng=rng).random(1)[0] - .5) * t_max/n
+t = t_base + np.concatenate(([0], lhs, [0]))
+t = t_base
+s = 5 * rng.random(n)
+
+t_interp = np.linspace(0, t_max, n_interp)
+s_interp = np.clip(CubicSpline(t, s)(t_interp), 0, 5)
+s_n = np.full_like(t_interp[::50], np.nan)
+s_n = np.floor(s_interp[::50] * 8 / 5)
+s_n[s_n == 8] = 7
+
+fig, ax = plt.subplots()
+ax2 = ax.twinx()
+
+ax.plot(t_interp, s_interp, lw=3)
+ax2.scatter(t_interp[::50], s_n, color="C1")
+
+ax.grid(False, axis="y")
+ax.grid(True, axis="x", which="both")
+ax2.grid(True)
+
+ax.set(
+  xlim=(0, t_max),
+  ylim=(-.5, 5.5),
+  xlabel="Temps (s)",
+)
+ax.set_ylabel("Signal analogique (V)", color="C0")
+ax2.set(
+  ylim=(-8/5*.5, 8/5*5.5),
+)
+ax2.set_ylabel("Signal numérique", color="C1")
+
+ax.yaxis.set_major_locator(ticker.MultipleLocator(1))
+ax.xaxis.set_major_locator(ticker.MultipleLocator(1))
+ax.xaxis.set_minor_locator(ticker.MultipleLocator(.5))
+ax2.set_yticks(np.arange(9), np.concatenate((np.arange(8), [""])))
+
+arr = ax2.annotate("", xy=(0, 0), xytext=(0.5, 0), arrowprops=dict(arrowstyle="<->"))
+ax2.annotate("$T_e$", (0.5, 1), xycoords=arr, ha="center", va="bottom")
+
+arr2 = ax2.annotate("", xy=(0.5, 0), xytext=(0.5, 1), arrowprops=dict(arrowstyle="<->"))
+ax2.annotate("$q$", (1, 0.5), xycoords=arr2, ha="left", va="center")
+
+arr3 = ax2.annotate("", xy=(1, 0), xytext=(1, 8), arrowprops=dict(arrowstyle="<->"))
+ax2.annotate("$V_{pe}$", (1, 0.5), xycoords=arr3, ha="left", va="center");
+:::
+Signal analogique et signal numérisé.
+::::
+
+::::{figure}
+:label: fig:carac-can
+:::{code-cell} python
+:tags: [remove-input]
+import matplotlib.pyplot as plt
+from matplotlib import ticker
+import numpy as np
+
+N = 8
+s_n = np.arange(N)
+s_a = np.linspace(0, 5, N+1)
+
+fig, ax = plt.subplots()
+
+ax.stairs(s_n, s_a, color="C1", lw=3, baseline=None)
+
+ax.set(
+  yticks=s_n,
+  xlabel="Signal analogique (V)",
+  ylabel="Signal numérique",
+)
+ax.set_xticks(s_a, [f"{v:.3f}" for v in s_a], rotation=45, ha="right", rotation_mode="anchor")
+ax.set_aspect(5/8, "datalim")
+arr4 = ax.annotate(
+    "", xy=(s_a[0], 0), xytext=(s_a[1], 0), arrowprops=dict(arrowstyle="<->")
+)
+ax.annotate("$q$", (0.5, 1), xycoords=arr4, ha="center", va="bottom")
+
+arr5 = ax.annotate(
+    "", xy=(s_a[0], 1.5), xytext=(s_a[-1], 1.5), arrowprops=dict(arrowstyle="<->")
+)
+ax.annotate("$V_{pe}$", (0.5, 1), xycoords=arr5, ha="center", va="bottom");
+:::
+Caractéristique du CAN.
+::::

cours/SIN/04-numeration.md

@@ -0,0 +1,111 @@
+---
+title: Systèmes de numération
+subject: Cours
+export:
+  - format: pdf
+    template: courstex
+---
+
+# Définition
+
+:::{prf:definition} Système de numération
+:nonumber: true
+Un système de numération est un ensemble de règles qui régissent une, voire plusieurs numérations données. De façon plus explicite, c'est un ensemble de règles d'utilisation des signes, des mots ou des gestes permettant d'écrire, d'énoncer ou de mimer les nombres.
+
+Source : Article _[Système de numération](https://fr.wikipedia.org/wiki/Syst%C3%A8me_de_num%C3%A9ration)_ de [Wikipédia en français](https://fr.wikipedia.org/) ([auteurs](https://fr.wikipedia.org/w/index.php?title=Syst%C3%A8me_de_num%C3%A9ration&action=history))
+:::
+
+# Systèmes de numération usuels
+
+## Le système décimal (base 10)
+
+Le système décimal est celui que l'on utilise au quotidien, qui utilise 10 symboles (0 à 9). La valeur des nombres s'obtient ainsi (@tab:num-10) :
+
+:::{math}
+1789=1 \times 10^3 + 7 \times 10^2 + 8 \times 10^1 + 9 \times 10^0
+:::
+
+:::{csv-table} Système décimal
+:label: tab:num-10
+10³,10²,10¹,10⁰
+1000, 100, 10, 1
+1,7,8,9
+:::
+
+## Le système binaire (base 2)
+
+Le système binaire est celui utilisé par systèmes électroniques. Il utilise 2 symboles (0 et 1). Chaque chiffre est appelé un bit. Un nombre à 8 bits est appelé octet (ou byte en anglais). La valeur des nombres s'obtient ainsi (@tab:num-2) :
+
+:::{math}
+1011_2=1 \times 2^3 + 0 \times 2^2 + 1 \times 2^1 + 1 \times 2^0
+:::
+
+:::{csv-table} Système binaire
+:label: tab:num-2
+2³,2²,2¹,2⁰
+8, 4, 2,1
+1,0,1,1
+:::
+
+### Conversion binaire vers décimal
+
+Pour convertir un nombre binaire en nombre décimal, utiliser la méthode ci-dessus : chaque bit, lui associer sa valeur, puis faire la somme des bits à 1.
+
+::::{hint} Exemple : Convertir $1101_2$ en décimal.
+
+- On associe à chaque bit sa valeur :
+:::{math}
+\begin{matrix}
+2³ & 2² & 2¹ & 2⁰ \\
+1 & 1 & 0 & 1
+\end{matrix}
+:::
+- On additione la valeur des bits à 1 :
+:::{math}
+N = 8+4+1 = 13_{10}
+:::
+::::
+
+### Conversion décimal vers binaire
+
+La méthode infaillible pour convertir un nombre décimal en nombre binaire est de poser la division par 2, puis réitérer avec le quotient obtenu jusqu'à obtenir 0, puis lire le reste des divisions en sens inverse.
+
+::::{hint} Exemple : Convertir $25_{10}$ en binaire.
+
+- On pose la division :
+    - $25\div 2=12\text{, reste }1$
+    - $12\div 2=6\text{, reste }0$
+    - $6\div 2=3\text{, reste }0$
+    - $3\div 2=1\text{, reste }1$
+    - $1\div 2=0\text{, reste }1$
+- On lit le reste des divisions dans l'ordre inverse : $25_{10}=11001_{2}$.
+::::
+
+## Le système hexadécimal (base 16)
+
+Le système hexadécimal est souvent utiliser pour retranscrire des nombres binaires car la conversion entre les deux systèmes est simple. Il utilise 16 symboles (0 à 9 puis A à F ; A=10, B=11, C=12, D=13, E=14 et F=15). La valeur des chiffres s'obtient ainsi (@tab:num-16) :
+
+:::{math}
+6FD_{16}=6\times 16²+15\times 16¹+13\times 16⁰
+:::
+
+:::{csv-table} Système hexadécimal
+:label: tab:num-16
+16²,16¹,16⁰
+256,16,1
+6,F,D
+:::
+
+### Conversion entre binaire et hexadécimal
+
+Pour convertir un nombre binaire en hexadécimal, on peut regrouper les bits en paquets de 4, puis convertir chaque groupe de 4 bits en un chiffre hexadécimal.
+
+:::{hint} Exemple : Convertir $0110\,1111\,1101_2$ en hexadécimal.
+
+- On groupe en paquets de 4 bits : $0110_2$, $1111_2$, $1101_2$.
+- On convertit chaque paquet en un chiffre hexadécimal :
+    - $0110_2=6_{10}=6_{16}$
+    - $1111_2=15_{10}=F_{16}$
+    - $1101_2=13_{10}=D_{16}$
+- On obtient donc : $0110\,1111\,1101_2=6FD_{16}$.
+:::

cours/SIN/05-logique.md

@@ -0,0 +1,70 @@
+---
+title: Logique combinatoire
+subject: Cours
+export:
+  - format: pdf
+    template: courstex
+kernelspec:
+  name: python3
+  display_name: Python 3
+---
+
+# Vocabulaire
+:::{prf:definition} Variable logique
+:nonumber: true
+Une **variable logique** est une variable qui ne peut prendre que deux valeurs, dites **états logiques** : 0 et 1.
+:::
+
+:::{prf:definition} Table de vérité
+:nonumber: true
+Une **table de vérité** permet de renseigner les états logiques des sorties du système en fonction de ses entrées (exemple : @tab:verite).
+:::
+
+:::{csv-table} Table de vérité
+:label: tab:verite
+:header-rows: 1
+a,b,S
+0,0,1
+0,1,0
+1,0,0
+1,1,1
+:::
+
+:::{prf:definition} Chronogramme
+:nonumber: true
+Un **chronogramme** permet de représenter l'évolution des états logiques d'un système en fonction du temps (exemple : @fig:chronogramme).
+:::
+
+::::{figure}
+:label: fig:chronogramme
+:::{code-cell} python
+:tag: [remove-input]
+import matplotlib.pyplot as plt
+import numpy as np
+
+rng = np.random.default_rng(25)
+
+fig, [ax_a, ax_b, ax] = plt.subplots(3, figsize=(10, 4), sharex=True, sharey=True)
+ax.set(xlim=(0, 16), xticks=np.arange(0, 16), ylim=(-0.5, 1.5), yticks=(0, 1))
+ax.set(xlabel="Temps (s)", ylabel="Signal logique")
+
+a = rng.integers(2, size=16)
+b = rng.integers(2, size=16)
+S = np.equal(a, b)
+
+ax_a.stairs(a, lw=3, baseline=None)
+ax_a.set_ylabel("a")
+
+ax_b.stairs(b, lw=3, baseline=None)
+ax_b.set_ylabel("b")
+
+ax.stairs(S, lw=3, baseline=None)
+ax.set_ylabel("S");
+:::
+
+Chronogramme
+::::
+
+# Fonctions logiques
+Une fonction logique donne un résultat en fonction des valeurs d'entrée.
+Les fonctions logiques usuelles sont ET ($a\cdot{}b$), OU ($a+b$), NON ($\bar a$) et OU exclusif (XOR, $a\oplus{}b$). Les symboles et tables de vérité sont donnés sur la [page Wikipédia des fonctions logiques](https://fr.wikipedia.org/wiki/Fonction_logique#Repr%C3%A9sentation_graphique).

cours/SIN/matplotlibrc

@@ -0,0 +1 @@
+../../matplotlibrc

courstex

@@ -0,0 +1 @@
+Subproject commit d040c12b630182d5b127a9123a0cfa617d9a0016

evaluation

@@ -0,0 +1 @@
+Subproject commit eac5d69f03c63e66fea32294ee3a48ff18facc58

main.py

@@ -0,0 +1,6 @@
+def main():
+    print("Hello from cours4-0!")
+
+
+if __name__ == "__main__":
+    main()

matplotlibrc

@@ -0,0 +1,43 @@
+lines.linewidth: 3
+
+font.family: DejaVu Sans Mono
+
+image.cmap: inferno
+
+axes.linewidth: 1
+axes.grid: True
+axes.grid.which: major
+axes.titlelocation: right
+axes.titleweight: 700
+axes.axisbelow: True
+
+axes.prop_cycle: cycler(color=["#4269d0","#efb118","#ff725c","#6cc5b0","#3ca951","#ff8ab7","#a463f2","#97bbf5","#9c6b4e","#9498a0"])
+
+axes.formatter.use_locale: True
+
+grid.color: "#bebebe"
+grid.linewidth: 1
+grid.alpha: 1
+
+hatch.linewidth: 8
+hatch.color: "#00000013"
+
+boxplot.showmeans: true
+boxplot.meanprops.markeredgecolor: "k"
+boxplot.meanprops.marker: "+"
+boxplot.flierprops.markerfacecolor: C0
+boxplot.medianprops.color: C0
+
+figure.figsize: 8, 4.5
+figure.dpi: 96
+figure.constrained_layout.use: True
+
+xtick.direction: in
+xtick.major.size: 4
+xtick.minor.size: 2
+
+ytick.direction: in
+ytick.major.size: 4
+ytick.minor.size: 2
+
+savefig.format: pdf

myst.yml

@@ -16,13 +16,15 @@ project:
       country: France
       url: https://lyceedupaysdesoule.fr
   license: CC-BY-NC-SA-4.0
-  exclude: README.md
+  exclude:
+    - README.md
+    - courstex
   numbering:
     headings: true
 site:
   template: book-theme
   options:
-    favicon: logo.svg
+    favicon: favicon.ico
     logo: logo.svg
     folders: true
     hide_footer_links: true

procédures/01-vr.md

@@ -6,6 +6,9 @@ abstract: |
   L'objectif de cette procédure est de visualiser un modèle 3D réalisé avec
   Solidworks en réalité augmentée avec l'application [Caddy](https://www.heycaddy.net/)
   sur Meta Quest 3.
+export:
+  - format: pdf
+    template: courstex
 ---
 
 # Export au format IGES

procédures/02-laser.md

@@ -4,7 +4,10 @@ subject: Procédure
 subtitle: Découper ou graver une pièce
 abstract: |
   L'objectif de cette procédure est de découper et graver une pièce dans une
-  plaque à l'aide de la découpe laser JAMP78 JA40.
+  plaque à l'aide de la découpe laser JAMP78 JA50.
+export:
+  - format: pdf
+    template: courstex
 ---
 
 # Import dans RdCAM
@@ -19,9 +22,118 @@ découpe ou la gravure (remplissage des contours). Les fichiers matriciels
 niveau de luminosité des pixels).
 :::
 
+:::{seealso} Voir aussi
+[Site de JAMP78](https://www.jamp78.fr/blog/telechargements/)
+:::
+
 # Interface
+
 L'interface de RdCAM se découpe en plusieurs zones :
 - au centre, la zone de dessin,
 - en haut et à gauche les barres d'outils,
 - à droite les réglages machine,
-- en bas la barre de sélection de calques.
+- en bas la barre de sélection de calques.
+
+Pour chaque tracé, on peut sélectionner un calque différent en le sélectionnant
+puis en cliquant sur l'un des calques en bas de l'écran (différentes couleurs).
+Les paramètres de gravure ou de découpe s'appliquent pour chaque calque.
+
+# Découpe
+
+Sélectionner le mode Cut dans les paramètres. La découpe suit les contours
+du tracé vectoriel. Les paramètres à définir sont la puissance du laser et la
+vitesse de déplacement. Des valeurs types sont données en @param-decoupe.
+
+:::{note}
+La puissance maximale est utilisée lorsque la vitesse de déplacement est maximale,
+en ligne droite.
+La puissance minimale est utilisée lorsque le laser est à vitesse réduite, dans
+les coins notamment.
+:::
+
+:::{warning} Attention
+Pour préserver la durée de la vie du laser, éviter de le faire fonctionner à 100%.
+:::
+
+```{list-table} Paramètres de découpe
+:header-rows: 1
+:label: param-decoupe
+* - Matériau
+  - Épaisseur (mm)
+  - Puissance min. (%)
+  - Puissance max. (%)
+  - Vitesse (mm/s)
+* - MDF
+  - 3
+  - 70
+  - 95
+  - 25
+* - MDF
+  - 6
+  - 70
+  - 95
+  - 10 ?
+* - PMMA
+  - 3
+  - 70 ?
+  - 90 ?
+  - 5 ?
+```
+
+# Gravure
+
+Sélectionner le mode Scan. La gravure se fait ligne par ligne en remplissant les
+tracés vectoriels ou suivant les zones sombres des images importées.
+Les paramètres à définir sont la puissance du laser et la vitesse de déplacement.
+Des valeurs types sont données en @param-gravure.
+
+:::{warning} Attention
+Le laser a besoin d'une phase d'accélération et de décélération de part et d'autre
+de la zone à graver. Si la zone gravée est trop près du bord de la machine, cela
+peut amener à une collision. Plus la vitesse est élevée, plus la zone d'accélération
+est grande.
+:::
+
+```{list-table} Paramètres de gravure
+:header-rows: 1
+:label: param-gravure
+* - Matériau
+  - Puissance (%)
+  - Vitesse (mm/s)
+* - MDF
+  - 75
+  - 250
+* - PMMA
+  - 70 ?
+  - 300 ?
+```
+
+# Lancement depuis une clé USB
+
+Générer le fichier `RD` avec le bouton en bas à droite de l'interface RdCAM.
+Le copier sur une clé USB.
+
+Sur la machine, insérer la clé USB dans le port Clé USB. Sur l'IHM de la machine,
+sélectionner File, chercher le fichier sur la clé USB puis le copier sur la machine.
+
+:::{attention}
+Ne pas oublier de supprimer le fichier de la machine après fabrication.
+:::
+
+Sélectionner l'origine machine (bouton Origin sur l'IHM). On peut utiliser le
+bouton Frame pour vérifier le bon positionnement de la découpe.
+Activer le laser avec la clé appropriée. Vérifier le réglage du potentiomètre
+du laser (100% en temps normal).
+Lancer la découpe avec le bouton Start.
+
+# Lancement depuis un ordinateur
+
+Connecter l'ordinateur à la machine avec le cable USB-B vers USB-B.
+
+Sélectionner le positionnement de la découpe, en faisant attention à la position
+de l'origine.
+On peut utiliser le bouton Voir Cadre pour vérifier le bon positionnement de la
+découpe.
+Activer le laser avec la clé appropriée. Vérifier le réglage du potentiomètre
+du laser (100% en temps normal).
+Sur RdCAM, lancer la découpe avec le bouton Lancer en bas à droite.

pyproject.toml

@@ -0,0 +1,15 @@
+[project]
+name = "cours4-0"
+version = "0.1.0"
+description = "Cours 4.0"
+readme = "README.md"
+requires-python = ">=3.13"
+dependencies = [
+    "mystmd",
+    "jupyter-server",
+    "ipykernel",
+    "matplotlib",
+    "numpy",
+    "pandas",
+    "scipy",
+]