Conclusion

La méthode retenue pour le mesurage[1] des grandeurs i et u a été celle consistant à utiliser un micro-contrôleur Arduino commandé par un programme en Python. Des mesures de tension à l'aide d'un multimètre numérique 2000 points n'ont pas montré de décalage significatif entre les mesures issues des deux méthodes de mesurage. En revanche, il convient de raisonner sur la valeur de la résistance étalon permettant d'accéder à la grandeur intensité du courant. Si la résistance étalon est trop faible par rapport à la résistance totale des dipôles en série, alors la mesure de la tension à ses bornes ne sera que quelques dizaines de fois la valeur du pas du CAN. L'erreur sur la mesure de i peut être importante.

Le programme Python est tout à fait perfectible. Il ne réalise pas la validité des données saisies par l'opérateur, ce qui est une source de plantage. Les caractéristiques produites méritent d'être mieux légendées, nuage de points et modèle.

1
# Créé par Gilles Claudel, le 21/11/2018 en Python 3.4
2
from commandesPython import Arduino
3
import time
4
import os
5
import matplotlib.pyplot as plt
6
import numpy as np
7
import scipy.stats as st
8
9
def fichImage(ref, nb):
10
    os.makedirs("u=f(i)",exist_ok=True)
11
    image = "u=f(i)/caracteristique_R" + ref + "_n" + str(nb) + "_modelisee.png"
12
    plt.savefig(image, dpi=300)	#sauvegarde du fichier image de la caractéristique u = f(i)
13
    return(0)
14
	
15
def fichMes(ref, nb, i, u):
16
    os.makedirs("mesures",exist_ok=True)
17
    fichier = "mesures/fichier_R" + ref + "_n" + str(nb) + ".txt"
18
    mes_mesures = open(fichier, "w")	#création ou écrasement d'un fichier ouvert en écriture
19
    j = 0
20
    mes_mesures.write("i (A),u (V)\n") #entête du fichier de mesure
21
    
22
    while j < nb:
23
        mes_mesures.write(str(i[j]/1000)+","+str(u[j])+"\n")	#Le séparateur est la virgule pour Geogebra
24
        j = j + 1
25
    
26
    mes_mesures.close()	#fermeture du fichier texte
27
    return(0)
28
29
def predict(x, a, b):
30
    return a * x + b
31
32
def notation(valeur, erreur, cs):
33
    n = int(np.log10(valeur))
34
    a = round(valeur/10**n,cs)
35
    err = round(erreur/10**n,cs)
36
    sortie = "\\left("+str(a)+" \\pm"+str(err)+" \\right) \\times 10^{"+str(n)+"}"
37
    return sortie
38
	
39
k=0
40
u=[]
41
i=[]
42
R=[]
43
44
port = "COM3"			#à modifier si besoin
45
ard = Arduino(port)		#La classe Arduino permet de communiquer via le port série avec le micro-contrôleur
46
47
#On teste les saisies et on vérifie si ce sont bien des nombres
48
dipole = input("Valeur de référence de la résistance ?\n")
49
50
while True:
51
    try:
52
        r = float(input("Valeur de la résistance étalon pour la mesure de l'intensité ?\n"))
53
        break
54
    except ValueError:
55
        print("Entrez un nombre.")
56
57
while True:
58
    try:
59
        n = int(input("Nombre de mesures ?\n"))
60
        break
61
    except ValueError:
62
        print("Entrez un nombre entier.")
63
64
print("Faire varier l'intensité du courant dans le dipôle pendant environ 5 secondes")
65
66
time.sleep(0.5)
67
#Période d'échantillonnage
68
T_e = 5.0/n	#durée entre deux mesures telle que la durée totale soit de 5 s
69
70
while k < n:
71
    sensorU2 = ard.analogRead(0)	#La lecture d'une entrée analogique et sa conversion A/N : ce n'est pas instantané
72
    time.sleep(0.001)
73
    sensorUr = ard.analogRead(1)
74
    time.sleep(0.001)
75
    sensorGND = ard.analogRead(2)
76
    time.sleep(0.001)
77
78
    u.append(((sensorU2-sensorUr)/1023.0)*5.0)      #u en V : u = u_2 - u_r
79
    i.append(((sensorUr-sensorGND)/1.023)*5.0/r)    #i en mA : i = u_r / r
80
81
    k = k + 1
82
    time.sleep(T_e)
83
84
ard.close()		#Après n mesures, on libère le port de communication
85
86
#
87
# Travail de l'élève
88
# - représenter un nuage de points associé à la caractéristique du dipôle
89
# - modéliser la caractéristique de ce dipôle
90
#
91
92
# Création du fichier texte de mesures pour une 1re exploitation dans Geogebra
93
    
94
fichMes(dipole, n , i, u)
95
time.sleep(1)
96
97
# On vide les listes i et u
98
i = []
99
u = []
100
# On rouvre le fichier
101
file = "mesures/fichier_R" + dipole + "_n" + str(n) + ".txt"
102
i,u = np.loadtxt(file, delimiter=',', skiprows=1, unpack='true')
103
104
titre = "Caractéristique courant/tension d'un dipôle ohmique"
105
106
titreX = "intensité en mA"
107
titreY = "tension en V"
108
# arrondi au milliampère supérieur de la valeur maximale de i
109
i_max = 1000*np.ceil(10**np.ceil(-np.log10(np.max(i)))*np.max(i))*10**np.floor(np.log10(np.max(i)))
110
u_max = np.ceil(np.max(u))     #arrondi au volt supérieur de la valeur maximale de u
111
112
# Etude statistique
113
114
a, b, r_value, p_value, std_err = st.linregress(i, u)
115
modele = predict(i, a, b)
116
117
# On fixe le nombre de chiffres significatifs
118
cs = 2
119
soustitre = "u = "+ str(round(a,0)) + " i +" + str(round(b,2))
120
legende = r"$R="+notation(a, std_err, cs)+"\;\Omega$"
121
t = 0.6*i_max  #abscisse de la légende
122
123
# Nuage de points à partir des première et deuxième colonnes du fichier texte
124
# Tracé du modèle linéaire
125
# On convertit l'intensité en mA
126
127
plt.scatter(1000*i, u, marker='+')    # i en mA, car i est en A dans le fichier texte
128
plt.plot(1000*i, modele, c='r', label='modèle linéaire')
129
130
plt.suptitle(titre)
131
plt.title(soustitre)
132
plt.xlabel(titreX)
133
plt.ylabel(titreY)
134
plt.axis([0,i_max,0,u_max])
135
136
# On annote le modèle en précisant la pente et son incertitude-type
137
plt.annotate(legende,xy=(t, a*t/1000+b), xycoords='data',xytext=(-150, +50), textcoords='offset points', fontsize=14, arrowprops=dict(arrowstyle="->", connectionstyle="arc3,rad=.2"))
138
139
# Sauvegarde en image de la caractéristique
140
fichImage(dipole, n)
141
142
plt.show()
143
144
plt.close()

L'archive contient les trois programmes (deux en Python et un en C++), des exemples de caractéristiques et le fichier Geogebra.

Le choix du tableur de Geogebra nous a semblé pertinent. L'outil est libre ; il est performant au niveau de l'analyse statistique, adapté aux programmes de mathématiques de lycée et permet de simuler les comportements des dipôles. Des activités hors la classe, tutorées, utilisant un groupe Geogebra sont un moyen de poursuivre l'activité au-delà de la séance.

Pour revenir aux objectifs d'apprentissage, l'activité se veut différente de ce que les élèves de collège ont pu faire autour de la loi d'Ohm et met l'accent sur la mesure et les incertitudes associées avec une approche qualitative et grandement étayée par les outils numériques. Elle est réalisable sur une séance d'une heure et vingt-cinq minutes à la condition que les élèves ne découvrent pas le langage Python. Une capsule vidéo leur montrant, en amont, comment relier des composants sur la breadboard à partir d'un schéma est souhaitable.

Mesure et incertitudes, la loi d'Ohm en seconde

Représenter la caractéristique d'un dipôle et son modèle à l'aide d'un langage de programmation (Python).

La vidéo décrit l'utilisation du microcontrôleur, du programme Python et des outils d'analyse statistique : Geogebra.