{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4201147c",
   "metadata": {},
   "outputs": [],
   "source": [
    "%serialconnect COM4 115200 # cellule de connexion au microcontroleur avec un boadrate de 115200\n",
    "#Question 1\n",
    "#Si la commande ne marche pas, vérifier le COM dans le gestionnaire de périphériques de l'ordinateur"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "90f27661-8742-48b5-82b8-19b54a9b3683",
   "metadata": {},
   "outputs": [],
   "source": [
    "#Question 1\n",
    "from machine import ADC, DAC, Pin\n",
    "\n",
    "adc = ADC(Pin(34)) # entrée analogique utilisée\n",
    "\n",
    "adc.atten(ADC.ATTN_11DB) # plage de mesure adaptée a l'ESP32\n",
    "\n",
    "N_CAN = adc.read() # conversion analogique\n",
    "print(N_CAN) # affichage de la valeur"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9eb9a291-75fa-4f9b-95d9-c71dbb90ddad",
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "%local\n",
    "%matplotlib notebook\n",
    "#Question 4\n",
    "\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import logging\n",
    "logging.getLogger(\"matplotlib\").setLevel(logging.WARNING)\n",
    "\n",
    "# Mesures expérimentales\n",
    "U_m = np.array([]) # à compléter tension mesurée (V)\n",
    "N_CAN = np.array([]) # à compléter valeur fournie par le CAN\n",
    "\n",
    "a, b = np.polyfit(U_m, N_CAN, 1) # ajustement affine : N_CAN = a * U_m + b\n",
    "\n",
    "# Valeurs calculées à partir de l'ajustement\n",
    "U_modele = np.linspace(0, max(U_m), 100)\n",
    "N_modele = a * U_modele + b\n",
    "\n",
    "# Tracé\n",
    "plt.close(\"all\")\n",
    "plt.figure(1)\n",
    "plt.plot(U_m, N_CAN, \"o\", label=\"Mesures\")\n",
    "plt.plot(U_modele, N_modele, label=\"Ajustement affine\")\n",
    "plt.xlabel(r\"$U_m$ (V)\")\n",
    "plt.ylabel(r\"$N_{\\mathrm{CAN}}$\")\n",
    "plt.grid()\n",
    "plt.legend()\n",
    "plt.show()\n",
    "\n",
    "# Résultats de l'ajustement\n",
    "print(\"Pente a =\", a, u\"V^-1$\")\n",
    "print(\"Ordonnée à l'origine b =\", b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ac0acd32-3e5c-46d6-816d-b0b427bc6e58",
   "metadata": {},
   "outputs": [],
   "source": [
    "#Question 6 et 11\n",
    "from time import ticks_us, ticks_diff, sleep_us\n",
    "from math import sin, pi\n",
    "\n",
    "fe = 800 # fréquence d'échantillonnage en Hz\n",
    "Te_micro = int(1e6/fe) # période d'échantillonnage en microseconde\n",
    "Na = 1000 # nombre d'échantillon\n",
    "\n",
    "t = [] # liste des instants de mesure en seconde\n",
    "u = [] # liste des tensions mesurées par l'ESP32\n",
    "\n",
    "for k in range(Na):\n",
    "    tk = ticks_us() # mesure de l'instant tk\n",
    "    t.append(tk*1e-6) # ajout de l'instant tk en seconde \n",
    "    u.append(  ) # à completer : quelle est la fonction à utiliser pour mesurer une tension ?\n",
    "    sleep_us(  ) # à completer : quelle est la période à attendre entre deux prises de mesure ?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "520b8b9e-d8fd-44a0-9a81-104f86f5b6dd",
   "metadata": {},
   "outputs": [],
   "source": [
    "%sync\n",
    "[t, u] = [t, u] # Transfert de données entre le microcontroleur et l'ordinateur\n",
    "#Question 8 et 11"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "165d685e",
   "metadata": {},
   "outputs": [],
   "source": [
    "%local\n",
    "#Question 7\n",
    "Tek = []\n",
    "for k in range(len(t)-1):\n",
    "    Tek.append(t[k+1]-t[k])\n",
    "Te = np.mean(np.array(Tek))\n",
    "fe=1/Te\n",
    "print(Te, fe)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "827a8e69-d606-4826-ba0e-c52d0b1ac9be",
   "metadata": {},
   "outputs": [],
   "source": [
    "%local\n",
    "#Question 8 et 11\n",
    "\n",
    "f_imposée =  # à compléter fréquence imposée en Hz\n",
    "\n",
    "# Conversion en tableaux numpy\n",
    "t = np.array(t)\n",
    "u = np.array(u)\n",
    "\n",
    "# Origine des temps\n",
    "t = t - t[0]\n",
    "\n",
    "# Tracé\n",
    "plt.close(\"all\")\n",
    "plt.figure(2)\n",
    "plt.plot(t, u, \"-o\", label=\"Mesures\")\n",
    "plt.xlabel(r\"$t$ (s)\")\n",
    "plt.ylabel(r\"$N_{\\mathrm{CAN}}$\")\n",
    "plt.grid()\n",
    "plt.legend()\n",
    "plt.xlim([0, 6/f_imposée])\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4a691cd7-ccfe-485b-a171-ebada8bcb21d",
   "metadata": {},
   "outputs": [],
   "source": [
    "%local\n",
    "#Question 9 et 11\n",
    "\n",
    "# Calcul de la FFT\n",
    "spectre = np.fft.rfft(u)\n",
    "freq = np.fft.rfftfreq(len(u), d=1/fe)\n",
    "\n",
    "# Amplitude du spectre\n",
    "amplitude = 2 / len(u) * np.abs(spectre)\n",
    "\n",
    "# Tracé\n",
    "plt.close(\"all\")\n",
    "plt.figure(3)\n",
    "plt.plot(freq, amplitude)\n",
    "plt.xlabel(r\"$f$ (Hz)\")\n",
    "plt.ylabel(\"Amplitude\")\n",
    "plt.grid()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9450a328",
   "metadata": {},
   "outputs": [],
   "source": [
    "%local\n",
    "#Questions 13, 14 et 15\n",
    "\n",
    "# Paramètres du filtre passe-bas\n",
    "fc =  # à compléter fréquence de coupure en Hz\n",
    "w0 =  # à compléter pulsation de coupure en rad.s-1\n",
    "H0 = 1.0\n",
    "\n",
    "# Période d'échantillonnage réelle\n",
    "Te = np.mean(np.diff(t))\n",
    "\n",
    "# Signal d'entrée\n",
    "e = u\n",
    "\n",
    "# Signal filtré\n",
    "s = np.zeros(len(e))\n",
    "s[0] = e[0]\n",
    "\n",
    "# Filtrage par Euler implicite\n",
    "for k in range(len(e)-1):\n",
    "    s[k+1] =  # à compléter schéma d'Euler \n",
    "    \n",
    "plt.close(\"all\")\n",
    "plt.figure(4)\n",
    "plt.plot(t, e, \"-o\", label=\"Signal non filtré\")\n",
    "plt.plot(t, s,\"--\", label=\"Signal filtré\")\n",
    "plt.xlabel(r\"$t$ (s)\")\n",
    "plt.ylabel(r\"$N_{\\mathrm{CAN}}$\")\n",
    "plt.xlim([0, 6/f_imposée])\n",
    "plt.grid()\n",
    "plt.legend()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ae5cf2a7",
   "metadata": {},
   "outputs": [],
   "source": [
    "%local\n",
    "#Question 15\n",
    "\n",
    "# FFT des deux signaux\n",
    "spectre_e = np.fft.rfft(e)\n",
    "spectre_s = np.fft.rfft(s)\n",
    "\n",
    "freq = np.fft.rfftfreq(len(e), d=Te)\n",
    "\n",
    "amplitude_e = 2/len(e) * np.abs(spectre_e)\n",
    "amplitude_s = 2/len(s) * np.abs(spectre_s)\n",
    "\n",
    "# Tracé\n",
    "plt.close(\"all\")\n",
    "plt.figure(5)\n",
    "plt.plot(freq, amplitude_e, label=\"Signal non filtré\")\n",
    "plt.plot(freq, amplitude_s,'--', label=\"Signal filtré\")\n",
    "plt.xlabel(r\"$f$ (Hz)\")\n",
    "plt.ylabel(\"Amplitude\")\n",
    "plt.grid()\n",
    "plt.legend()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "325ad92a",
   "metadata": {},
   "outputs": [],
   "source": [
    "%disconnet # permet de déconnecter le microcontrôleur"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "MicroPython upydevice kernel",
   "language": "python",
   "name": "micropython-upydevice"
  },
  "language_info": {
   "codemirror_mode": "python",
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "pygments_lexer": "python"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}