{
"cells": [
{
"cell_type": "code",
"execution_count": 1,
"metadata": {
"tags": []
},
"outputs": [],
"source": [
"import matplotlib.pyplot as plt # Importe le module pyplot en plt\n",
"import numpy as np # Importe la bibliothèque numpy en np\n",
"from scipy.stats import linregress\n",
"import matplotlib.ticker as ticker\n",
"from IPython.display import display, HTML"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"# Principe du radar de recul\n",
"\n",
"## I. Célérité des ultrasons dans l'air\n",
"### 1. Mesures"
]
},
{
"cell_type": "code",
"execution_count": 2,
"metadata": {
"tags": []
},
"outputs": [
{
"data": {
"text/html": [
"\n",
"\t\n",
"\t\n",
"\t\n",
"\t \n",
"\t \n",
"\t \n",
"\t\n",
"\t\n",
"\t\n",
"\t\n",
"\t \n",
"\t \n",
"\t \n",
"\t \n",
"\t\n",
"\t\n",
"\t\n",
"\n",
"\t"
],
"text/plain": [
""
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"from web_sciences import WebSciences\n",
"\n",
"my_init = '''\n",
"mode = \"point\";\n",
"commandes = [{texte_bouton:\"Mesure\", arduino:\"mesure\"}];\n",
"series = [{grandeur: \"Δt\", unite: \"µs\"}];\n",
"titre_graphe = \"Célérité des ultrasons dans l'air\";\n",
"axes = [{grandeur: \"d\", unite: \"cm\"}, {grandeur: \"Δt\", unite: \"µs\"}];\n",
"tableau_masjuscule = true;\n",
"tableur = true;\n",
"'''\n",
"\n",
"interface = WebSciences(my_init)\n",
"interface.affiche()"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### 2. Exploitation"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"#### a. Saisie des mesures et évaluation des incertitudes"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"tags": []
},
"outputs": [],
"source": [
"# mesures obtenues\n",
"# copier ci-dessous les tableaux de valeurs donnés par le notebook ultrasons_mesures\n",
"D = [10, 15, 20, 25, 30, 35, 40, 45, 50, 55, 60]\n",
"ΔT = [520.0, 800.0, 1108.0, 1420.0, 1716.0, 1996.0, 2276.0, 2576.0, 2876.0, 3140.0, 3352.0]\n",
"\n",
"'''\n",
"D = [10, 20, 30, 40, 50, 60, 70, 80, 90]\n",
"ΔT = [576, 1.18e+3, 1.75e+3, 2.30e+3, 2.90e+3, 3.46e+3, 4.04e+3, 4.67e+3, 5.25e+3]\n",
"'''\n",
"\n",
"# distance (m)\n",
"D = [d * 1e-2 for d in D]\n",
"# durée (s)\n",
"ΔT = [δt * 1e-6 for δt in ΔT]\n",
"# incertitudes sur d\n",
"D_ErrorValues = [1e-2 for valeur in D]\n",
"# incertitudes sur t\n",
"T_ErrorValues = [100e-6 for valeur in ΔT]"
]
},
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"#### b. Paramétrage du graphique et choix des grandeurs placées en abscisse et en ordonnée"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"slideshow": {
"slide_type": "-"
},
"tags": []
},
"outputs": [],
"source": [
"# calcul du modèle\n",
"Modele = linregress(D, ΔT)\n",
"m, p = Modele[0], Modele[1]\n",
"T_modele = [m*d+p for d in D]\n",
"plt.figure(\"Célérité des ultrasons\", figsize=(10, 7))# Initialise la figure\n",
"plt.title(\"Célérité des ultrasons dans l'air\",fontsize = 20)# Titre du graphe\n",
"plt.xlabel('$d (m)$',fontsize = 18) # Label de l’axe des abscisses\n",
"plt.ylabel('$\\Delta t (s)$',fontsize = 18) # Label de l’axe des ordonnées\n",
"ax=plt.gca()\n",
"ax.spines['right'].set_color('none')\n",
"ax.spines['top'].set_color('none')\n",
"ax.xaxis.set_major_formatter(ticker.FormatStrFormatter('%0.2f'))\n",
"ax.yaxis.set_major_formatter(ticker.FormatStrFormatter('%0.2e'))\n",
"plt.xticks(fontsize=14)\n",
"plt.ticklabel_format(axis='x')\n",
"plt.ticklabel_format(axis='y')\n",
"plt.yticks(fontsize=14)\n",
"T_abscisse = D\n",
"T_ordonnee = ΔT\n",
"plt.plot(T_abscisse, T_ordonnee, 'r.', ms=8, label='Points expérimentaux') # Points expérimentaux\n",
"plt.plot(T_abscisse, T_modele, 'b--', label='Régression linéaire', lw=1)\n",
"plt.errorbar(T_abscisse, T_ordonnee, xerr = D_ErrorValues, yerr = T_ErrorValues, fmt = 'none',\n",
" capsize = 2, ecolor = 'green', zorder = 1)\n",
"plt.grid()\n",
"plt.legend(fontsize=14)\n",
"plt.show()\n",
"# Affichage de la modélisation\n",
"m_t = '$m = '+str.replace('{:.2e}'.format(m),'e',' \\\\times 10^{').replace('.',',')+'}~s.m^{-1}$'\n",
"s = 'Modélisation de la droite : $\\\\Delta t = m \\\\times d$ avec {}'.format(m_t)\n",
"display(HTML(s))"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"#### 3. Détermination de la célérité des ultrasons"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"$\\Delta t = m \\times d$\n",
"\n",
"or\n",
"\n",
"$2 \\times d = v \\times \\Delta t$ soit $\\Delta t = \\dfrac{2}{V} \\times d$\n",
"\n",
"$\n",
"\\begin{cases} \n",
"\\Delta t = m \\times d \\\\\n",
"\\Delta t = \\dfrac{2}{V} \\times d\n",
"\\end{cases}\n",
"$\n",
"\n",
"On en déduit $m = \\dfrac{2} {v}$ et $v = \\dfrac{2} {m}$ "
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"tags": []
},
"outputs": [],
"source": [
"v = 2/m\n",
"print('v = {:.1f} m.s-1'.format(v))"
]
},
{
"cell_type": "markdown",
"metadata": {
"tags": []
},
"source": [
"## II. Application au Radar de recul\n",
"### 1. Cahier des charges\n",
"On souhaite utiliser la plaquette pour fabriquer un radar de recul. Le cahier des charges est le suivant :\n",
"\n",
"- Lorsque le radar est situé à plus d’un mètre de l’obstacle :\n",
" - la del verte doit être allumée et la del rouge doit être éteinte\n",
" - le buzzer ne doit émettre aucun son\n",
"- Lorsque le radar est situé entre 50 cm et 1,00 m de l’obstacle :\n",
" - la del verte doit être allumée et la del rouge doit être éteinte\n",
" - le buzzer doit émettre un bip toutes les 300 ms\n",
"- Lorsque le radar est situé à moins de 50 cm de l’obstacle :\n",
" - la del verte doit être éteinte et la del rouge doit être allumée\n",
" - le buzzer doit émettre un bip toutes les 125 ms"
]
},
{
"cell_type": "markdown",
"metadata": {
"tags": []
},
"source": [
"### 2. Manipulation\n",
"\n",
"Compléter le programme _programme_2.ino_ de façon à répondre au cahier des charges puis téléverser le sur la maquette\n",
"\n",
"```c\n",
"const float VITESSE_SON = 340.0; // Vitesse du son en m/s\n",
"const int pin_Trigger = 4;\n",
"const int TIMEOUT = (6/VITESSE_SON)*1e6; // TIMEOUT en µs (pour 6,0m aller/retour)\n",
"const int pin_led_verte = 3;\n",
"const int pin_led_rouge = 4;\n",
"const int pin_buzzer = 2;\n",
"\n",
"/* Renvoie la distance mesurée en cm */\n",
"float getDistance() {\n",
" unsigned long temps1;\n",
" unsigned long duree_ar;\n",
" pinMode(pin_Trigger, OUTPUT);\n",
" digitalWrite(pin_Trigger, HIGH);\n",
" delayMicroseconds(10);\n",
" digitalWrite(pin_Trigger, LOW);\n",
" pinMode(pin_Trigger, INPUT);\n",
" while (digitalRead(pin_Trigger) == LOW) { }\n",
" temps1 = micros();\n",
" while (digitalRead(pin_Trigger) == HIGH and micros() - temps1 < TIMEOUT) { }\n",
" // durée aller retour en mètres\n",
" duree_ar = micros() - temps1;\n",
" // Distance en mètres\n",
" float distance = duree_ar*1e-6 * VITESSE_SON / 2; \n",
" return distance;\n",
"}\n",
"\n",
"void setup() {\n",
" pinMode(pin_Trigger, OUTPUT);\n",
" pinMode(pin_buzzer, OUTPUT);\n",
" pinMode(pin_led_rouge, OUTPUT);\n",
" pinMode(pin_led_verte, OUTPUT);\n",
" Serial.begin(9600);\n",
" delay(1);\n",
"}\n",
"\n",
"void loop() {\n",
" float distance;\n",
" distance = getDistance(); \n",
" /* distance inférieure à 50cm */\n",
" if(distance < 0.50) {\n",
" digitalWrite(pin_led_rouge, HIGH);\n",
" digitalWrite(pin_led_verte, LOW);\n",
" tone(pin_buzzer,600,125);\n",
" delay(125);\n",
" }\n",
" /* distance comprise entre 0.50m et 1.0m*/\n",
" else if(distance < 1.0) {\n",
" digitalWrite(pin_led_rouge, LOW);\n",
" digitalWrite(pin_led_verte, HIGH);\n",
" tone(pin_buzzer,600,125);\n",
" delay(300);\n",
" }\n",
" else {\n",
" /* distance supérieure à 1.0m*/\n",
" digitalWrite(pin_led_rouge, LOW);\n",
" digitalWrite(pin_led_verte, HIGH);\n",
" delay(125);\n",
" }\n",
"}\n",
"\n",
"```"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": []
}
],
"metadata": {
"celltoolbar": "Format de la Cellule Texte Brut",
"kernelspec": {
"display_name": "Python 3",
"language": "python",
"name": "python3"
},
"language_info": {
"codemirror_mode": {
"name": "ipython",
"version": 3
},
"file_extension": ".py",
"mimetype": "text/x-python",
"name": "python",
"nbconvert_exporter": "python",
"pygments_lexer": "ipython3",
"version": "3.7.3"
},
"widgets": {
"application/vnd.jupyter.widget-state+json": {
"state": {},
"version_major": 2,
"version_minor": 0
}
}
},
"nbformat": 4,
"nbformat_minor": 4
}