---
# System prepended metadata

title: Travaux pratiques d'électronique N°1

---

# Travaux pratiques d'électronique N°1

## L'oscilloscope Numérique : outil de visualisation et d'acquisition de signaux

# Géneration de signaux 

Le générateur permet l'émission de signaux de périodes distinctes, lorsque l'on essaye d'émettre un signal d'une période différente, on remarque que les signaux ne sont plus en phase. 

Pour la suite du TP, nous utiliserons un jeu de données fournis par un camarade qui a pu capturer un signal de type différentiel TTL en plus.

# Visualisation et mesures 

![](https://i.imgur.com/BD9w8c8.png)

Le signal généré est de forme sinusoïdale, d'après les fonctions de mesures de l'oscilloscope ses caractéristiques sont les suivantes:

* Période T = 1.2 ms
* Valeur Moyenne = 2 V
* Tension crête à crête = 10 V
* Valeur efficace = 4 V

Pour faire des mesures temporelles très précises il faudrait privilégier plusieurs périodes pour les signaux émis.

# Analyse et interprétation 

Pour une fonction périodique, la valeur moyenne se calcule sur une période, ainsi on a : 

$<$e(t)$>$ = $\frac{1}{T}$$\int_0^T \mathrm{e(t)}\,\mathrm{d}t$

La tension crête à crête est définie comme différence entre sa crête positive et sa crête négative, ainsi on a : 

$Ucàc$ = $(Umax)-(Umin)$

La valeur efficace est la racine carrée de la moyenne du carré de cette grandeur, sur un intervalle de temps donné, donc ici sur une période, ainsi on a : 

$E_{effT}$ = $\sqrt{<e^2>}$ = $(\frac{1}{T}$$\int_0^T \mathrm{e(t)}^2\,\mathrm{d}t)^\frac{1}{2}$


# Traitement des données et exploitation via python

Après avoir traité les données sous excel, nous avons commencé le traitement numérique sous python. Tout d'abord, nous avons importé les modules nécessaires a ce traitement: 

```python
import numpy as np
import matplotlib.pyplot as plt
import math 
```
Ensuite, nous avons ouvert notre fichier sous la forme d'un tableau numérique via le module numpy. Puis nous avons effectué une vérification sur l'exploitabilité des données en lisant les 100 premiers caractères de notre fichier : 
```python 
    with open("data.csv") as f:
        data = f.read(100)
    print(data)
```
Grâce à cette vérification, nous avons pu observer un problème dans les deux premières lignes de nos données:

<center>
<img src="https://i.imgur.com/F1pXhdD.png">
</center>


En effet, le fichier contient uniquement des valeurs numériques à l'exception de ces 2 lignes, représentant le nom des axes ,des courbes et des unités représentées sur l'oscilloscope. 
Pour pouvoir proceder a l'exploitation, nous allons nous debarasser de ces lignes grâce à l'instruction suivante:

```python=
data = np.loadtxt("./data.csv", skiprows=2 , delimiter = ";", unpack = True)
```

# Représentation graphique
```python= 
t,x,y  = data
t_ms=t*1000 #Conversion du temps en seconde vers les milisecondes
            #Pour une meilleure lisibilité du graphique

plt.title("Représentation graphique de la tension en fonction du temps")
plt.plot(t_ms, x, color="green", label="Tension Voie 1")
plt.plot(t_ms, y, color="red", label="Tension Voie 2")

plt.xlabel("Temps en Milisecondes")
plt.ylabel("Tension en Volts")
plt.grid()
plt.legend(loc="upper left") #Emplacement des legendes
plt.gcf().set_size_inches(8, 6, forward=True)
plt.gcf().set_dpi(100)
plt.savefig("fig.jpg")
plt.show()
```
![](https://i.imgur.com/AahhL33.png)

>Les courbres verte et rouge représentent respectivement la tension e(t) et la tension u(t).

Après avoir obtenu cette représentation graphique, nous avons écrit et appliqué les fonctions suivantes à nos données afin d'obtenir différentes grandeurs statistique.

### Periode de e(t)
```python=
dt = t[1]-t[0]

def periode(entrée):
    moy = (np.max(entrée) + np.min(entrée))/2
    compteur = -1
    i = 0
    t1= 0  
    while compteur != 1:
        if entrée[i] < moy < entrée[i+1]:
            compteur += 1
            if compteur == 0:
                t1 = i
        i+=1
    return (i-t1)*dt

print(periode(x))
print(periode(y))
```
### Valeur moyenne
```python=
def moyenne(entrée):
    T = periode(entrée)
    v = int(T/(dt))
    somme = 0
    for k in range(v-1):
        somme +=  dt * (entrée[k]+entrée[k+1])/2
    return (1/T)*somme

print(moyenne(x))
print(moyenne(y))
```
Cela nous renvoie : 
* moyenne(x) = 1.8428731039561663
* moyenne(y) = 1.4871873096278492


### Tension crête à crête
```python=
def cac(entrée):
    return(np.amax(entrée)-np.amin(entrée))

print(cac(x))
print(cac(y))
```

### Valeur efficace
```python=
def valeur_efficace(entrée):
    T = periode(entrée)
    v = int(T/dt)
    somme = 0
    for k in range(v-1):
        somme +=  dt * ((entrée[k])**2+(entrée[k+1])**2)/2
    return np.sqrt((1/T)*somme)

print(valeur_efficace(x))
print(valeur_efficace(y))
```
En l'appliquant à nos données, nous obtenons:
* V_eff(x) = 4.012748197581136
* V_eff(y) = 2.129450875727477

En comparant les sorties de nos fonctions avec les valeurs réelles affichées des mesures de l'oscilloscope, on remarque que les valeurs sont en corrélation, la période est bien de 1.2 ms, la tension crête à crête est bien de 10 V, la tension moyenne (=1.8 V) est proche de celle attendue (2V)