Add course material on combinatorial logic with definitions, truth tables, and logical functions

.forgejo/workflows/serve.yaml

@@ -8,13 +8,23 @@ jobs:
     steps:
       - name: Checkout repository
         uses: actions/checkout@v4
+        with:
+          submodules: "true"
       - name: Initialize virtual environment
-        run: /usr/bin/python -m venv .env
+        run: /usr/bin/python -m venv .venv
       - name: Install dependencies
-        run: ./.env/bin/pip install mystmd jupyter jupyterlab_myst ipykernel altair pandas
+        run: ./.venv/bin/pip install -r requirements.txt
+      - name: Execute code
+        run: |
+          . .venv/bin/activate
+          myst build --execute
+      - name: Build PDF exports
+        run: |
+          . .venv/bin/activate
+          myst build --execute --pdf
       - name: Build static HTML
         run: |
-          . .env/bin/activate
+          . .venv/bin/activate
           myst build --execute --html
       - name: Copy files
         run: |

.gitmodules

@@ -0,0 +1,3 @@
+[submodule "courstex"]
+	path = courstex
+	url = https://git.edgarpierre.fr/edpibu/courstex.git

README.md

@@ -3,4 +3,4 @@
 <https://cours.edgarpierre.fr>
 
 [![Made with MyST](https://img.shields.io/badge/made%20with-myst-orange)](https://myst.tools)
-[![Forgejo Actions](https://img.shields.io/badge/serve.yaml-success-brightgreen)](https://git.edgarpierre.fr/edpibu/cours4.0/actions?workflow=serve.yaml)
+[![Forgejo Actions](https://git.edgarpierre.fr/edpibu/cours4.0/badges/workflows/serve.yaml/badge.svg)](https://git.edgarpierre.fr/edpibu/cours4.0/actions?workflow=serve.yaml)

cours/SIN/01-capteurs.md

@@ -1,6 +1,9 @@
 ---
 title: Les capteurs
 subject: Cours
+export:
+  - format: pdf
+    template: courstex
 ---
 
 # Définition
@@ -28,10 +31,9 @@ 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}
-:label: tor
 :::{figure} https://upload.wikimedia.org/wikipedia/commons/3/3a/Switches-electrical.agr.jpg 
 :label: inter
+:width: 50%
 
 Interrupteur[^inter].
 
@@ -41,6 +43,7 @@ Interrupteur[^inter].
 
 :::{figure} https://upload.wikimedia.org/wikipedia/commons/2/2e/Motion_detector.jpg
 :label: pir
+:width: 50%
 
 Détecteur de mouvement PIR[^pir].
 
@@ -48,9 +51,6 @@ Détecteur de mouvement PIR[^pir].
 Public domain, via Wikimedia Commons.
 :::
 
-Exemples de capteurs tout ou rien
-::::
-
 ## Les capteurs analogiques
 Le signal de sortie est en relation directe avec la grandeur d'entrée
 (généralement proportionnelle)
@@ -59,10 +59,9 @@ c'est un signal dit **analogique**.
 Une thermistance (@thermistance) ou une jauge de déformation (@jauge) sont des
 capteurs analogiques.
 
-::::{figure}
-:label: analogique
 :::{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].
 
@@ -73,6 +72,7 @@ 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].
 
@@ -80,17 +80,13 @@ Jauge de déformation : résistance variant selon son élongation[^jauge].
 [CC BY-SA 4.0](https://creativecommons.org/licenses/by-sa/4.0), via Wikimedia Commons.
 :::
 
-Exemples de capteurs analogiques.
-::::
-
 ## 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}
-:label: numeriques
 :::{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].
 
@@ -98,12 +94,10 @@ Caméra : pour chaque pixel, le signal peut prendre une valeur entière allant d
 :::
 :::{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
-:::
-
-Exemples de capteurs numériques
-::::
+:::

cours/SIN/02-signaux.md

@@ -1,6 +1,9 @@
 ---
 title: Les signaux
 subject: Cours
+export:
+  - format: pdf
+    template: courstex
 kernelspec:
   name: python3
   display_name: Python 3
@@ -29,40 +32,34 @@ Un signal logique ne peut prendre que deux valeurs : un niveau **haut** ("High")
 et un niveau **bas** ("Low").
 
 ````{figure}
-:label: logique
+:label: fig:sig-logique
 ```{code-cell} python
 :tags: [remove-input]
-import altair as alt
+import matplotlib.pyplot as plt
+from matplotlib import ticker
 import numpy as np
-import pandas as pd
 
 rng = np.random.default_rng(25)
 
 n = 16
 t = np.arange(n+1)
-s = rng.choice([0, 1], n+1)
-s[-1] = s[-2]
-data = pd.DataFrame({
-  "t": t,
-  "s": s,
-})
-alt.Chart(
-  data
-).mark_line(
-  interpolate="step-after",
-  strokeWidth=3,
-).encode(
-  alt.X("t:Q").axis(title="Temps (s)").scale(domain=(0,n)),
-  alt.Y("s:Q", axis=alt.Axis(title="Signal logique", values=[0, 1], format=".0f")).scale(domain=(0,1)),
-).properties(
-  width="container",
-  height=100,
+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 @logique est par exemple à l'état haut entre 2 s et 3 s,
+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**.
@@ -71,41 +68,43 @@ 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 @analogique.
+Un exemple de signal analogique est donné en @fig:sig-analogique.
 
 ````{figure}
-:label: analogique
+:label: fig:sig-analogique
 ```{code-cell} python
 :tags: [remove-input]
-import altair as alt
+import matplotlib.pyplot as plt
+from matplotlib import ticker
 import numpy as np
-import pandas as pd
+from scipy.interpolate import CubicSpline
+from scipy.stats import qmc
+
 
 rng = np.random.default_rng(25)
 
 n = 20
 t_max = 16
 
-t = np.linspace(0, t_max, n)
-
+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)
-s[-1] = s[-2]
-data = pd.DataFrame({
-  "t": t,
-  "s": s,
-})
-alt.Chart(
-  data
-).mark_line(
-  interpolate="basis",
-  strokeWidth=3,
-).encode(
-  alt.X("t:Q").axis(title="Temps (s)").scale(domain=(0,t_max)),
-  alt.Y("s:Q", axis=alt.Axis(title="Signal analogique")).scale(domain=(0,5)),
-).properties(
-  width="container",
-  height=200,
+
+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
 ````
@@ -113,38 +112,32 @@ 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 @numerique.
+Un exemple de signal analogique est donné en @fig:sig-numerique.
 
 ````{figure}
-:label: numerique
+:label: fig:sig-numerique
 ```{code-cell} python
 :tags: [remove-input]
-import altair as alt
+import matplotlib.pyplot as plt
+from matplotlib import ticker
 import numpy as np
-import pandas as pd
 
 rng = np.random.default_rng(25)
 
 n = 16
 t = np.arange(n+1)
-s = rng.integers(0, 16, n+1)
-s[-1] = s[-2]
-data = pd.DataFrame({
-  "t": t,
-  "s": s,
-})
-alt.Chart(
-  data
-).mark_line(
-  interpolate="step-after",
-  strokeWidth=3,
-).encode(
-  alt.X("t:Q").axis(title="Temps (s)").scale(domain=(0,n)),
-  alt.Y("s:Q", axis=alt.Axis(title="Signal numérique", values=np.arange(0, 16))).scale(domain=(0,15)),
-).properties(
-  width="container",
-  height=200,
+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

matplotlibrc

@@ -0,0 +1,43 @@
+lines.linewidth: 3
+
+font.family: Fira Code
+
+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,7 +16,9 @@ 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:

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

@@ -5,6 +5,9 @@ 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 JA50.
+export:
+  - format: pdf
+    template: courstex
 ---
 
 # Import dans RdCAM

requirements.txt

@@ -0,0 +1,7 @@
+mystmd
+jupyter-server
+ipykernel
+matplotlib
+numpy
+pandas
+scipy