Expériences de physique avec Arduino : capteurs, tableau, graphe

Pour mener des expériences de physique avec Arduino, il y a six étapes : les élèves écrivent d'abord une question mesurable et une hypothèse, puis branchent le bon capteur sur l'Arduino ; la carte envoie chaque mesure sur le port série avec son horodatage, au format "zaman_ms,deger" (temps en ms, valeur) ; la courbe se suit en direct dans le traceur série ; les lignes du moniteur série sont copiées dans un fichier CSV puis importées dans un tableur ; on trace le graphe et on rédige la conclusion en le comparant à l'hypothèse. Contrairement à une mesure faite à la main avec un thermomètre et un chronomètre, l'Arduino relève 60 points en 10 minutes, à intervalles réguliers, sans fatigue ni erreur de lecture. Le travail de l'élève n'est donc plus de recopier des valeurs, mais d'interpréter des données.

Cet article propose trois expériences prêtes à l'emploi pour les cours de physique-chimie et de SVT : la courbe de refroidissement de l'eau chaude avec un DS18B20, la variation de l'éclairement avec la distance avec une LDR, et le mouvement sur un plan incliné avec un HC-SR04 (avec, en bonus, la mesure de la vitesse du son). Pour chacune, tu trouveras la question, les variables, le matériel, le résumé du câblage, un code qui compile, un modèle de tableau de données et le résultat attendu. Viennent ensuite les étapes du traceur série et de l'import dans un tableur, un tableau des erreurs de mesure et de l'étalonnage, le déroulé de 2 séances de 40 minutes, un modèle court de compte rendu de TP et les consignes de sécurité. Les exemples partent d'une hypothèse : disons que tu as une classe de 24 élèves, répartis en 6 groupes de 4, et que chaque groupe dispose d'un Arduino Uno et d'un ordinateur. Nous n'entrons pas ici dans le détail du câblage des capteurs ; un lien vers le guide de chaque capteur est donné au bon endroit.

Expérience de physique avec Arduino en 6 étapes : de la question à la conclusion

1. Question et hypothèse : choisis une question mesurable ("L'eau chaude refroidit-elle plus vite pendant les 5 premières minutes ou pendant les 5 suivantes ?") et fais écrire l'hypothèse sur le modèle "Si …, alors …, parce que …". L'hypothèse doit contenir un sens de variation ou un nombre ; dire "ça change" ne suffit pas.
2. Variables : fais noter dans un tableau la variable indépendante (celle que tu fais varier : temps, distance, inclinaison), la variable dépendante (celle que le capteur mesure : température, lumière, position) et les variables contrôlées (quantité d'eau, même lampe, même planche). Quand une expérience échoue, la cause est souvent une variable qui n'a pas été maintenue constante.
3. Capteur et code : branche le capteur et téléverse le code. Le code écrit chaque ligne au format "zaman_ms,deger" ; la première ligne est un en-tête qui donne le nom des colonnes. La carte compte le temps elle-même avec millis(), plus besoin de chronomètre.
4. Suivi en direct : avant l'essai enregistré, observe un court essai dans le traceur série. Si la courbe saute de façon inattendue (fil mal enfoncé, ombre, main sur le capteur), corrige tout de suite ; s'en rendre compte après la mesure, c'est trop tard.
5. Données et tableau : copie les lignes du moniteur série, enregistre-les dans un fichier .csv, importe-le dans le tableur et ajoute la conversion d'unité (ms → s) et les colonnes de calcul.
6. Graphe et conclusion : trace un graphe XY (nuage de points), donne un nom et une unité à chaque axe, compare le graphe à l'hypothèse et rédige une conclusion appuyée sur les données : "Notre hypothèse est validée, ou non, parce que …".

Liste du matériel et résumé du câblage

Expérience 1 : courbe de refroidissement de l'eau chaude (DS18B20)

Question : l'eau chaude perd-elle la même quantité de chaleur chaque minute, ou son refroidissement ralentit-il peu à peu ? Exemple d'hypothèse : "Quand l'écart de température entre l'eau et la pièce est grand, le refroidissement est rapide ; il ralentit quand l'écart diminue." Variable indépendante : le temps ; variable dépendante : la température de l'eau ; variables contrôlées : la quantité d'eau (200 mL), le type de récipient, sa place sur la table et la température de la pièce. Tu peux aussi donner une seconde question aux groupes : y a-t-il une différence entre une tasse avec et sans couvercle, ou entre un verre et un gobelet en carton ? La variable indépendante devient alors le type de récipient ; deux groupes mesurent en même temps et comparent leurs courbes. Pour le câblage et l'installation des bibliothèques, consulte le guide du DS18B20. Si tu n'as qu'un DHT11, ne le plonge jamais dans l'eau : l'expérience équivalente sans risque consiste à réchauffer le capteur une minute dans la main, à le poser sur la table et à mesurer son refroidissement à l'air (guide du DHT11).

1// Deney 1: Sıcak suyun soğuma eğrisi / Experiment 1: cooling curve of hot water
2// Kütüphaneler: OneWire + DallasTemperature / Libraries: OneWire + DallasTemperature
3#include <OneWire.h>
4#include <DallasTemperature.h>
5
6const int ONE_WIRE_PIN = 2;                // DS18B20 veri (DQ) pini / data (DQ) pin
7const unsigned long INTERVAL_MS = 10000;   // 10 saniyede bir ölçüm / one reading every 10 s
8const bool PLOTTER_MODE = false;           // true: Serial Plotter için yalnız değer / value only for Serial Plotter
9
10OneWire oneWire(ONE_WIRE_PIN);
11DallasTemperature sensors(&oneWire);
12unsigned long startMs = 0;
13unsigned long lastMs = 0;
14
15void setup() {
16  Serial.begin(9600);
17  sensors.begin();
18  if (!PLOTTER_MODE) {
19    Serial.println("zaman_ms,sicaklik_C");  // CSV başlık satırı / CSV header line
20  }
21  startMs = millis();
22  lastMs = startMs - INTERVAL_MS;           // ilk ölçüm hemen / first reading right away
23}
24
25void loop() {
26  unsigned long now = millis();
27  if (now - lastMs < INTERVAL_MS) {
28    return;                                 // daha zamanı gelmedi / not time yet
29  }
30  lastMs += INTERVAL_MS;                    // kaymayan zamanlama / drift-free timing
31
32  sensors.requestTemperatures();            // ölçümü başlat (~750 ms) / start conversion (~750 ms)
33  float tempC = sensors.getTempCByIndex(0);
34  if (tempC == DEVICE_DISCONNECTED_C) {     // sensör yanıt vermedi / sensor did not respond
35    return;
36  }
37
38  if (PLOTTER_MODE) {
39    Serial.print("sicaklik_C:");
40    Serial.println(tempC, 2);
41  } else {
42    Serial.print(now - startMs);            // deney başından beri ms / ms since start
43    Serial.print(",");
44    Serial.println(tempC, 2);
45  }
46}

Le code écrit une ligne toutes les 10 secondes ; 20 minutes de mesure donnent 120 lignes. Le temps vient du compteur millis() de la carte, et comme on ajoute exactement 10 000 à la variable lastMs à chaque fois, les mesures ne dérivent pas ; le détail de cette technique est dans l'article millis() et delay(). Si tu passes PLOTTER_MODE à true en haut du code, la colonne du temps disparaît et le traceur série ne dessine que la température. Le modèle ci-dessus est le tableau résumé qui ira dans le compte rendu, les données complètes restent dans le fichier CSV ; mesure la température de la pièce au début, avec le même capteur dans l'air. Résultat attendu : la courbe n'est pas une droite mais une courbe qui s'aplatit : la température baisse vite pendant les premières minutes, puis la baisse ralentit. C'est la loi de refroidissement de Newton : la vitesse de refroidissement est proportionnelle à l'écart de température entre l'objet et son environnement. Les élèves qui calculent la dernière colonne voient que l'écart diminue à peu près de la même fraction sur des durées égales ; disons que l'écart a été divisé par deux en 8 minutes, il sera de nouveau divisé par deux au cours des 8 minutes suivantes. La tasse avec couvercle refroidit plus lentement, car elle perd moins de chaleur par évaporation. En SVT, la même expérience répétée avec un petit et un grand récipient permet de discuter de la raison pour laquelle les petits animaux perdent leur chaleur plus vite.

Expérience 2 : éclairement et distance (LDR)

Question : comment l'éclairement diminue-t-il quand on s'éloigne d'une source de lumière ; si la distance double, la lumière est-elle divisée par deux ou par quatre ? Exemple d'hypothèse : "Quand la distance double, l'éclairement est divisé par quatre." Variable indépendante : la distance entre la lampe et la LDR (10, 15, 20, 30, 40 et 50 cm) ; variable dépendante : la valeur lue sur A0 ; variables contrôlées : même lampe, mêmes piles, lampe dirigée perpendiculairement vers la LDR et lumière ambiante. Fais l'expérience rideaux fermés, si possible lumières baissées : si la lumière ambiante est forte, l'apport de la lampe se perd aux grandes distances. Avec ce câblage, la valeur lue augmente avec la lumière ; le principe du pont diviseur est expliqué dans le guide de la LDR. Fais glisser la lampe le long du mètre ruban, attends 5 secondes à chaque distance que la valeur se stabilise et note dans le tableau trois valeurs successives du moniteur série. Au début, fais une mesure lampe éteinte : c'est la valeur de fond de la pièce. Si la valeur à la plus grande distance est très proche du fond, ne garde pas cette distance sur le graphe.

1// Deney 2: Işık şiddeti ve mesafe / Experiment 2: light intensity and distance
2// Bağlantı: 5V - LDR - A0 - 10 kΩ - GND / Wiring: 5V - LDR - A0 - 10 kΩ - GND
3const int LDR_PIN = A0;                    // bölücünün orta noktası / divider midpoint
4const unsigned long INTERVAL_MS = 500;     // yarım saniyede bir satır / one line every 0.5 s
5const int SAMPLES = 16;                    // ortalama için örnek sayısı / samples per average
6const bool PLOTTER_MODE = false;           // true: Serial Plotter için yalnız değer / value only for Serial Plotter
7
8unsigned long startMs = 0;
9unsigned long lastMs = 0;
10
11int readAverage() {
12  long sum = 0;
13  for (int i = 0; i < SAMPLES; i++) {
14    sum += analogRead(LDR_PIN);             // 0 (karanlık) ... 1023 (aydınlık) / dark ... bright
15    delay(2);
16  }
17  return (int)(sum / SAMPLES);              // gürültüyü azaltır / reduces noise
18}
19
20void setup() {
21  Serial.begin(9600);
22  if (!PLOTTER_MODE) {
23    Serial.println("zaman_ms,ldr_ham");     // CSV başlık satırı / CSV header line
24  }
25  startMs = millis();
26  lastMs = startMs - INTERVAL_MS;           // ilk ölçüm hemen / first reading right away
27}
28
29void loop() {
30  unsigned long now = millis();
31  if (now - lastMs < INTERVAL_MS) {
32    return;
33  }
34  lastMs += INTERVAL_MS;
35
36  int raw = readAverage();
37  if (PLOTTER_MODE) {
38    Serial.print("ldr_ham:");
39    Serial.println(raw);
40  } else {
41    Serial.print(now - startMs);            // deney başından beri ms / ms since start
42    Serial.print(",");
43    Serial.println(raw);
44  }
45}

Toutes les demi-secondes, le code écrit la moyenne de 16 mesures ; les petites fluctuations d'une lecture analogRead isolée s'effacent ainsi. Pour calculer la résistance de la LDR, si la moyenne brute est en colonne F, écris en colonne G la formule =10000*(1023-F3)/F3 et recopie-la vers le bas (pour une résistance fixe de 10 kΩ et une LDR reliée au 5V). Résultat attendu : la valeur lue baisse quand la distance augmente, vite de près, lentement de loin. Mais la valeur brute n'est pas divisée par quatre entre 10 et 20 cm, car ce nombre ne représente pas l'éclairement : il traduit la tension du pont diviseur. Pour voir la loi en inverse du carré, place la distance et la résistance de la LDR sur un graphe à deux axes logarithmiques : les points s'alignent à peu près sur une droite. L'éclairement est inversement proportionnel au carré de la distance, et la résistance de la LDR est à peu près inversement proportionnelle à l'éclairement élevé à la puissance γ ; la pente de la droite vaut donc 2 × γ et non 2. Pour les LDR courantes, γ est le plus souvent compris entre 0,5 et 0,9, donc on attend une pente entre 1 et 1,8. Au lycée, c'est une bonne occasion de discuter de la question : "comment le comportement de l'instrument de mesure influence-t-il le résultat ?"

Expérience 3 : mouvement sur un plan incliné et vitesse du son (HC-SR04)

Question : une petite voiture lâchée sur un plan incliné descend-elle à vitesse constante ou accélère-t-elle ? Comment l'accélération change-t-elle avec l'inclinaison ? Exemple d'hypothèse : "Sur des durées égales, la voiture parcourt une distance de plus en plus grande, elle accélère donc ; plus la pente est forte, plus l'accélération est grande." Variable indépendante : le temps (au second essai, l'inclinaison : 1, 2 et 3 livres) ; variable dépendante : la distance entre la voiture et le capteur ; variables contrôlées : la voiture, le point de départ et la planche. Montage : surélève une extrémité d'une planche droite de 1 à 1,5 m avec des livres et place le HC-SR04 à l'extrémité basse, tourné vers la planche. Colle un carton de 10 × 10 cm à l'arrière de la petite voiture : le capteur ne reçoit pas d'écho fiable sur les objets petits et arrondis, alors qu'un carton plat renvoie un écho net. Tiens la voiture à environ 100 cm du capteur, lâche-la, et pose un livre devant le capteur pour éviter qu'elle ne le percute. Le principe de fonctionnement et la portée du capteur sont dans le guide du HC-SR04.

1// Deney 3: Eğik düzlemde hareket ve ses hızı / Experiment 3: motion on a ramp and speed of sound
2const int TRIG_PIN = 9;                    // tetik / trigger
3const int ECHO_PIN = 10;                   // yankı / echo
4const unsigned long INTERVAL_MS = 60;      // ölçümler arası en az ~60 ms / at least ~60 ms between pings
5const bool PLOTTER_MODE = false;           // true: Serial Plotter için yalnız değer / value only for Serial Plotter
6const bool RAW_ECHO_US = false;            // true: ses hızı deneyi için yankı süresi (µs) / echo time for speed of sound
7
8unsigned long startMs = 0;
9unsigned long lastMs = 0;
10
11void setup() {
12  pinMode(TRIG_PIN, OUTPUT);
13  pinMode(ECHO_PIN, INPUT);
14  digitalWrite(TRIG_PIN, LOW);
15  Serial.begin(9600);
16  if (!PLOTTER_MODE) {
17    Serial.println(RAW_ECHO_US ? "zaman_ms,yanki_us" : "zaman_ms,mesafe_cm");  // CSV başlığı / CSV header
18  }
19  startMs = millis();
20  lastMs = startMs - INTERVAL_MS;           // ilk ölçüm hemen / first reading right away
21}
22
23void loop() {
24  unsigned long now = millis();
25  if (now - lastMs < INTERVAL_MS) {
26    return;
27  }
28  lastMs += INTERVAL_MS;
29
30  digitalWrite(TRIG_PIN, LOW);
31  delayMicroseconds(2);
32  digitalWrite(TRIG_PIN, HIGH);             // 10 µs tetik darbesi / 10 µs trigger pulse
33  delayMicroseconds(10);
34  digitalWrite(TRIG_PIN, LOW);
35
36  unsigned long echoUs = pulseIn(ECHO_PIN, HIGH, 25000UL);  // en fazla 25 ms (~4 m) / max 25 ms (~4 m)
37  if (echoUs == 0) {                        // yankı yok, satırı atla / no echo, skip the line
38    return;
39  }
40  float distanceCm = echoUs * 0.0343 / 2.0; // 343 m/s, gidiş-dönüş / round trip
41
42  if (PLOTTER_MODE) {
43    Serial.print("mesafe_cm:");
44    Serial.println(distanceCm, 1);
45  } else {
46    Serial.print(now - startMs);            // deney başından beri ms / ms since start
47    Serial.print(",");
48    if (RAW_ECHO_US) {
49      Serial.println(echoUs);
50    } else {
51      Serial.println(distanceCm, 1);
52    }
53  }
54}

Le code écrit une ligne toutes les 60 ms, soit environ 16 lignes par seconde ; il est conseillé de laisser cet intervalle entre deux mesures pour que les échos du HC-SR04 ne se mélangent pas. Si aucun écho ne revient (objet hors de portée ou incliné), la ligne est sautée. Ne calcule pas la vitesse à partir de deux lignes successives mais avec 5 lignes d'écart : sur un intervalle de 60 ms, même une fluctuation de mesure de 1 à 2 mm fait beaucoup varier la vitesse. Résultat attendu : le graphe position-temps n'est pas une droite mais une courbe de plus en plus pentue (une parabole) ; le graphe vitesse-temps, lui, est à peu près une droite : la voiture accélère avec une accélération constante, donnée par la pente de cette droite. Sur un plan incliné sans frottement, l'accélération vaudrait g × sin θ : avec une planche de 1,5 m surélevée de 10 cm, sin θ ≈ 0,067, soit une accélération d'environ 65 cm/s². Si la valeur mesurée est plus faible, c'est à cause des frottements et de la rotation des roues, et on le note comme source d'erreur dans le compte rendu. Variante vitesse du son : passe RAW_ECHO_US à true, place un carton plat face au capteur à 20, 40, 60, 80 et 100 cm et fais la moyenne de la durée de l'écho à chaque distance. Sur le graphe avec le trajet aller-retour (2 × d) en abscisse et la durée en ordonnée, la pente vaut 1/v ; on trouve v vers 340 m/s à température ambiante, et v augmente avec la température (environ v ≈ 331 + 0,6 × T m/s). La méthode de la pente élimine en plus d'elle-même le retard fixe interne du capteur.

Traceur série et import des données dans un tableur

1. Après le téléversement, ouvre Outils > Moniteur série et choisis 9600 bauds, comme dans le code. L'horodatage doit être désactivé : sinon l'heure de l'ordinateur s'ajoute au début de chaque ligne et le CSV est faussé.
2. Avant de commencer, efface la sortie et appuie sur le bouton RESET de la carte. Le temps repart ainsi de 0 et la première ligne est un en-tête comme zaman_ms,sicaklik_C.
3. Pour une courbe en direct, passe PLOTTER_MODE à true dans le code, téléverse de nouveau et ouvre Outils > Traceur série. Le traceur série n'enregistre rien, il affiche seulement ; utilise-le pour l'essai de réglage, et remets PLOTTER_MODE à false pour l'essai enregistré.
4. À la fin de la mesure, sélectionne à la souris les lignes du moniteur série, de l'en-tête à la dernière ligne, puis copie-les avec Ctrl+C (Cmd+C sur macOS). Colle-les dans un éditeur de texte brut et enregistre le fichier sous un nom qui indique le groupe, l'expérience et la date, par exemple groupe2-refroidissement-0411.csv.
5. Importe le fichier dans le tableur : dans Excel avec Données > À partir d'un fichier texte/CSV, dans Google Sheets avec Fichier > Importer, dans LibreOffice Calc en ouvrant directement le fichier. Choisis la virgule comme séparateur.
6. Attention au séparateur décimal : l'Arduino écrit 23.50 avec un point, alors qu'un tableur réglé en français attend une virgule. À l'import, choisis les paramètres régionaux Anglais (États-Unis) ou remplace les points par des virgules ; sinon 23.50 est lu comme du texte ou comme une date et le graphe reste vide.
7. Ajoute les colonnes de calcul (ms → s, écart, fraction, vitesse) et trace un graphe XY (nuage de points). Un graphique en courbes traite l'axe horizontal comme des catégories également espacées ; dès qu'une ligne manque, l'axe du temps est faussé.

Un bon graphe d'expérience se reconnaît à quatre éléments : la variable indépendante en abscisse, la variable dépendante en ordonnée, un nom et une unité sur chaque axe ("Temps (s)", "Température (°C)") et un titre qui dit ce qu'il montre ("Refroidissement de 200 mL d'eau dans une tasse sans couvercle"). Afficher deux conditions sur le même graphe avec deux couleurs (avec et sans couvercle, 1 et 3 livres) permet de comparer d'un coup d'œil. Avant de regarder le graphe, demande aux élèves de répondre sur papier par une esquisse à la question "Si notre hypothèse est juste, à quoi doit ressembler le graphe ?" ; poser le vrai graphe à côté de l'esquisse est le moyen le plus simple de rédiger la conclusion. La conclusion doit toujours s'appuyer sur un nombre : "L'eau a perdu … °C pendant les 5 premières minutes et … °C pendant les 5 suivantes." Les règles pour fixer l'échelle et nommer les courbes dans le traceur série sont expliquées dans le guide du moniteur série. Si tu ne veux pas copier à la main les longues mesures, tu peux écrire les données directement dans un fichier avec Python, ou, pour mesurer sans ordinateur, faire un enregistrement CSV avec un module carte SD.

Erreurs de mesure et étalonnage

Déroulé du cours : 2 séances de 40 minutes

Le déroulé ci-dessous convient aux trois expériences. Pour une première fois, nous te conseillons de donner l'expérience 1 à tous les groupes : c'est la plus simple à monter, et pendant que la mesure tourne seule, les groupes peuvent préparer leur tableau. Une fois la classe habituée, tu peux répartir les 6 groupes en trois ateliers de deux ; quand deux groupes font la même expérience, ils peuvent aussi comparer leurs résultats. Téléverser les codes sur les cartes avant le cours fait gagner 8 à 10 minutes sur la première séance. Pour les rôles et l'organisation en ateliers dans une classe chargée, vois l'article sur la classe à effectif chargé ; pour le matériel et l'aménagement des paillasses, le guide du laboratoire Arduino au lycée.

• Quelles étaient la variable indépendante et la variable dépendante, quelle variable as-tu maintenue constante ?
• Dans quelle partie du graphe la variation est-elle la plus rapide, et à quoi le vois-tu sur le graphe ?
• Ton hypothèse est-elle validée ? Sur quels deux nombres t'appuies-tu pour le dire ?
• Si l'intervalle de mesure avait été de 60 secondes au lieu de 10, comment ton graphe aurait-il changé ?
• Quelle était la principale source d'erreur, et que changerais-tu si tu refaisais l'expérience ?

Évaluation : modèle court de compte rendu de TP

• Titre et question : nom de l'expérience, membres du groupe, date et question de l'expérience en une phrase.
• Hypothèse : sur le modèle "Si …, alors …, parce que …", telle qu'elle a été écrite avant la mesure ; on ne la corrige pas après coup.
• Variables : la variable indépendante, la variable dépendante et au moins deux variables contrôlées.
• Matériel et protocole : capteur, résumé du câblage, intervalle de mesure et nombre de répétitions ; assez clair pour qu'un autre groupe puisse refaire l'expérience, en 6 étapes au maximum.
• Données : le tableau résumé comme dans le modèle, avec en plus le nom du fichier CSV.
• Graphe : graphe XY avec noms des axes, unités et titre.
• Conclusion : l'hypothèse est-elle validée ? 2 ou 3 phrases appuyées sur un ou deux nombres.
• Sources d'erreur et améliorations : au moins deux sources d'erreur et ce que tu changerais en refaisant l'expérience. Pour la notation, tu peux adapter à ces rubriques les critères de l'article grille d'évaluation pour un cours Arduino.

Projets avec capteurs dans l'application, Comprendre le code et outils

Pour tous les capteurs de ces expériences, BlueGrays propose des projets prêts avec schéma de câblage, liste des composants et code ; les élèves peuvent s'en servir pour découvrir le capteur avant l'expérience. Les projets gratuits : Mesurer l'intensité lumineuse avec une LDR, HC-SR04 Mesure de la distance (affichage en série) et Température et humidité avec DHT11 ; si tu utilises un ESP32, Mesure de l'intensité lumineuse avec le module LDR ESP32, ESP32 HC-SR04 Télémètre à ultrasons et ESP32 DHT22 Température et humidité (avec écran LCD) sont gratuits aussi. Dans les projets gratuits, les blocs et la section Comprendre le code sont également ouverts : l'élève lit étape par étape ce que fait le code et fait lui-même une petite modification dans l'exercice À toi de jouer ; la façon de l'utiliser en classe est expliquée dans l'article Comprendre le code. Pour calculer la tension du pont diviseur de l'expérience avec la LDR, l'outil Pont diviseur (Premium) fait l'affaire, et pour vérifier les résistances, les outils gratuits Code couleur et Loi d'Ohm. Si tu veux ouvrir à toute la classe des projets Premium avec capteurs, comme Mesure de la température avec NTC et écran LCD 2x16, qui affiche la température sur un écran LCD, ou Enregistreur de Température ESP32 (DHT22 + DS1307 RTC + microSD + OLED), qui enregistre les données sur une carte microSD, les paquets éducateur, à paiement unique et qui permettent aux élèves de passer Premium sans ajouter de carte bancaire, sont faits pour ça.

Sécurité : eau chaude, électricité et proximité de l'eau

• Eau chaude : n'utilise pas d'eau bouillante ; environ 60 °C suffit et la courbe reste nette. C'est l'enseignant qui distribue l'eau ; les tasses restent au milieu de la table, là où personne ne peut se prendre les pieds ou les mains dans les fils. Pendant la mesure, on ne tient pas la tasse et on ne la déplace pas.
• Eau et électricité : seul l'embout métallique de la sonde étanche va dans l'eau. L'Arduino, la breadboard et l'ordinateur restent à au moins 30 cm du récipient, de préférence sur un plateau séparé. Si de l'eau se renverse sur la table, débranche d'abord le câble USB, puis essuie.
• Uniquement l'alimentation USB : toutes ces expériences sont alimentées par le port USB de l'ordinateur ; aucun appareil branché sur le secteur (bouilloire, lampe, radiateur) n'est relié au circuit Arduino.
• Câblage : fais et modifie les branchements quand l'USB est débranché. Si un composant chauffe ou si une odeur apparaît, débranche l'USB immédiatement.
• Lumière : ne dirige la lampe vers les yeux de personne ; regarder de près une lampe à LED puissante est éblouissant et gênant pour les yeux.
• Plan incliné : la planche ne dépasse pas de la table, un livre arrête la voiture avant qu'elle ne heurte le capteur, et les livres sous la planche sont placés de façon à ne pas glisser.

Un capteur, une sortie CSV propre et une question bien posée transforment l'expérience du cours de physique : on ne refait plus le résultat du manuel, on mène une vraie étude de mesure. Les élèves tracent leurs propres graphes, discutent de leurs propres sources d'erreur et défendent leur conclusion avec leurs propres nombres. Pour découvrir les capteurs avant l'expérience et monter les circuits pas à pas depuis ton téléphone, tu peux commencer par les projets gratuits LDR, HC-SR04 et DHT11 de l'application BlueGrays.