3.7 KiB
| title | subject | kernelspec | abbreviations | ||||||
|---|---|---|---|---|---|---|---|---|---|
| Le CAN | Cours |
|
|
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 de Wikipédia en français (auteurs) :::
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).
:label: fig:exemple-can
```{code-cell} python
:tags: [remove-input]
import altair as alt
import numpy as np
import pandas as pd
from scipy import interpolate
rng = np.random.default_rng(25)
n = 20
t_max = 16
T = np.linspace(0, t_max, 1601)
y = np.clip(
interpolate.BSpline(np.linspace(0, t_max, n), 5 * rng.random(n), 2)(T),
0,
5,
)
y_n = np.full([1601], np.nan)
y_n[::50] = np.floor(y[::50] * 8 / 5)
y_n[y_n == 8] = 7
data = pd.DataFrame({
"t": T,
"s": y,
"s_n": y_n,
})
base = alt.Chart(
data
).encode(
alt.X("t:Q").axis(title="Temps (s)").scale(domain=(0,t_max)),
)
ch = base.mark_line(
interpolate="basis",
strokeWidth=3,
color="#6666cc",
).encode(
alt.Y("s:Q", axis=alt.Axis(title="Signal analogique", titleColor="#6666cc")).scale(domain=(0,5)),
)
ch_n = base.mark_point(
filled=True,
color="#ff6600",
).encode(
alt.Y(
"s_n:Q",
axis=alt.Axis(
title="Signal numérisé",
titleColor="#ff6600",
values=np.arange(8),
)
).scale(domain=(0,8)),
)
alt.layer(ch_n, ch).resolve_scale(
y="independent",
).properties(
width="container",
height=200,
)
```
Signal analogique et signal numérisé.
:label: fig:carac-can
```{code-cell} python
:tags: [remove-input]
import altair as alt
import numpy as np
import pandas as pd
from scipy import interpolate
N = 8
s_n = np.arange(N+1)
s_n[-1] = s_n[-2]
data = pd.DataFrame({
"s_n": s_n,
"s_a": np.linspace(0, 5, N+1),
})
alt.Chart(
data
).mark_line(
interpolate="step-after",
strokeWidth=3,
color="#ff6600",
).encode(
alt.X("s_a:Q").axis(title="Signal Analogique").scale(domain=(0,5)),
alt.Y("s_n:Q", axis=alt.Axis(title="Signal numérique", values=np.arange(N))).scale(domain=(0,N)),
).properties(
width=200,
height=200,
)
```
Caractéristique du CAN.