{"id":1417,"date":"2024-09-10T06:09:17","date_gmt":"2024-09-10T04:09:17","guid":{"rendered":"https:\/\/labopothier.com\/?p=1417"},"modified":"2024-09-23T11:39:13","modified_gmt":"2024-09-23T09:39:13","slug":"activite-arduino-python-recuperer-avec-python-les-donnees-dune-carte-arduino-pour-tracer-la-caracteristique-dune-ldr-avec-regression-lineaire-2","status":"publish","type":"post","link":"https:\/\/labopothier.com\/index.php\/2024\/09\/10\/activite-arduino-python-recuperer-avec-python-les-donnees-dune-carte-arduino-pour-tracer-la-caracteristique-dune-ldr-avec-regression-lineaire-2\/","title":{"rendered":"ACTIVITE ARDUINO\/PYTHON : R\u00e9cup\u00e9rer avec Python les donn\u00e9es d’une carte Arduino pour tracer la caract\u00e9ristique d’une LDR (avec r\u00e9gression lin\u00e9aire)"},"content":{"rendered":"\n

Pr\u00e9-requis : <\/strong> \u00eatre familier avec le langage Python … et \u00e9ventuellement avoir des bases en programmation pour les microcontr\u00f4leurs Arduino (mais pas obligatoire car on peut partir d’une carte Arduino d\u00e9j\u00e0 programm\u00e9e avec un code inconnu et s’en sortir quand m\u00eame !)<\/p>\n\n\n\n

Pour l’initiation au langage Python , je vous invite \u00e0 consulter cet article Initiation au langage Python<\/a><\/p>\n\n\n\n

D\u00e9couverte des microcontr\u00f4leurs et du langage Arduino disponible dans cet article : D\u00e9couverte des microcontr\u00f4leurs et du langage Arduino<\/a><\/p>\n\n\n\n

Si cette biblioth\u00e8que n’est pas install\u00e9e (pour le v\u00e9rifier, tester dans le shell import serial <\/strong>), il faudra \u00e9crire dans le shell (interpr\u00e9teur) :<\/p>\n\n\n\n

pip install serial<\/code><\/pre>\n\n\n\n
Nous allons partir du montage suivant (vu d\u00e9j\u00e0 dans l’activit\u00e9 <\/a>Trac\u00e9 de caract\u00e9ristique d’une photor\u00e9sistance<\/a>). Les mesures dans le code Arduino se font en continu (boucle infinie avec while(true)<\/strong>) <\/p>\n\n\n\n
Rappel : <\/strong>Tracer la caract\u00e9ristique U = f(I) d\u2019une photor\u00e9sistance en faisant varier une tension (\u00e0 l\u2019aide d\u2019un potentiom\u00e8tre) aux bornes d\u2019une association s\u00e9rie LDR-r\u00e9sistance connue (par exemple  1k\u03a9).<\/p>\n\n\n\n
\"\"<\/figure>\n\n\n\n
Bonus<\/strong> : Faire une r\u00e9gression lin\u00e9aire en utilisant le module  linregress <\/strong>(en important le module stats<\/strong> de scipy<\/strong>).<\/p>\n\n\n\n
\nfloat R= 1000;\nint const broche_LDR = A0;\nint const broche_alim = A1;\nint Valeur_LDR;\nint Valeur_alim;\nfloat U_alim;\nfloat U_LDR;\n\n\/\/==================================================================================================\n\/\/ Proc\u00e9dure d'initialisation des p\u00e9riph\u00e9riques\n\/\/==================================================================================================\nvoid setup() {\n  \/\/ Initialisation de la communication s\u00e9rie avec le terminal \u00e0 9600 baud.\n  Serial.begin(9600);\n  \n}\n\n\n\/\/==================================================================================================\n\/\/ Boucle principale Arduino.\n\/\/==================================================================================================\nvoid loop() {\n\n\n\n\n\n  \/\/ Mesures de la tension U_LDR en faisant varier U_alim avec le potentiom\u00e8tre\n\n  while(true)\n  { \n    Valeur_alim = analogRead(broche_alim); \/\/ Valeur comprise entre 0 et 1023\n    U_alim = Valeur_alim *5.0\/1023; \/\/ Calcul de la tension U_alim\n    Valeur_LDR   = analogRead(broche_LDR); \/\/ Valeur comprise entre 0 et 1023\n    U_LDR = (float)Valeur_LDR*5\/1023; \/\/Calcul de la tension aux bornes de la photor\u00e9sistance\n    \n    delay(1000);       \/\/ D\u00e9lai en ms pour la stabilisation de la tension \n                       \/\/pour la mesure de r\u00e9sistances.\n    \n   \n    float courant_A   = (U_alim - U_LDR)\/R; \/\/Calcul de l'intensit\u00e9 du courant en A\n\n    \/\/Affichage des resultats\n\n\n    Serial.print(\" Tension LDR: \");   \/\/ Affichage de la tension en V sur le moniteur s\u00e9rie\n    Serial.print(U_LDR);            \n    Serial.print(\" V\");              \n  \n    Serial.print(\" Courant: \");          \/\/ Affichage du courant en mA sur le moniteur s\u00e9rie\n    Serial.print(courant_A*1000);       \n    Serial.print(\" mA\");                \n    \n    Serial.println(\"\");                 \/\/ Saut de ligne.\n\n  }\n           \n}<\/code><\/pre>\n\n\n\n
Voil\u00e0 ce qui s’affiche dans le moniteur s\u00e9rie d’Arduino :<\/p>\n\n\n\n
\"\"<\/figure>\n\n\n\n
On souhaiterait r\u00e9cup\u00e9rer ces donn\u00e9es dans Python pour tracer un graphe, r\u00e9cup\u00e9rer ces valeurs dans un fichier txt, …<\/p>\n\n\n\n
Etape 1 : R\u00e9cup\u00e9rer les valeurs dans Python pour les stocker dans une liste<\/strong><\/h2>\n\n\n\n
Pour la communication avec la liaison s\u00e9rie de la carte Arduino (via le c\u00e2ble USB), il faut faire appel \u00e0 la biblioth\u00e8que serial <\/strong>en \u00e9crivant ces deux lignes :<\/p>\n\n\n\n
#Importation des modules\nimport serial\nimport serial.tools.list_ports   # pour la communication avec le port s\u00e9rie<\/code><\/pre>\n\n\n\n
On initialise les listes :<\/p>\n\n\n\n
# Initialisation des listes \n\nlines = ['I(mA)\\tU(V)\\n'] # premi\u00e8re ligne du fichier texte dans lequel on enregistrera les donn\u00e9es\nU = []  # liste pour les valeurs de tension aux bornes de la LDR\nI = []  # liste pour les valeurs d'intensit\u00e9 du courant<\/code><\/pre>\n\n\n\n
On d\u00e9finit une fonction qui permet \u00e0 la fois :<\/p>\n\n\n\n
    \n
  • de d\u00e9tecter automatiquement <\/strong>le port s\u00e9rie utilis\u00e9 par la carte Arduino <\/li>\n\n\n\n
  • de se connecter <\/strong>\u00e0 la carte<\/li>\n\n\n\n
  • de r\u00e9cup\u00e9rer <\/strong>les donn\u00e9es s\u00e9rie venant de la carte<\/li>\n<\/ul>\n\n\n\n
    # Fonction pour la r\u00e9cup\u00e9ration des donn\u00e9es s\u00e9rie venant de la carte Arduino\ndef recup_port_Arduino() :\n    ports = list(serial.tools.list_ports.comports())\n    for p in ports:\n        if 'Arduino' in p.description :\n            mData = serial.Serial(p.device,9600)\n    print(mData.is_open) # Affiche et v\u00e9rifie que le port est ouvert\n    print(mData.name) # Affiche le nom du port \n    return mData\n<\/code><\/pre>\n\n\n\n
    Remarque <\/strong>: cette fonction a \u00e9t\u00e9 \u00e9crite ici de la mani\u00e8re la plus basique possible, on pourrait rajouter des lignes de code suppl\u00e9mentaires pour g\u00e9rer les exceptions (pas de carte Arduino d\u00e9tect\u00e9, choisir entre plusieurs cartes Arduino connect\u00e9es en m\u00eame temps …)<\/p>\n\n\n\n
    \n
    Note pour les utilisateurs de MAC<\/strong><\/p>\n\n\n\n
    Il semblerait que le mot \u00ab\u00a0Arduino\u00a0\u00bb n’apparaisse pas dans les descriptions de port. Pour la reconnaissance de carte, remplacer la ligne <\/p>\n\n\n\n
    if  \u00ab\u00a0Arduino\u00a0\u00bb in p.descripton : <\/strong>     par     if \u00ab\u00a0CDC\u00a0\u00bbin p.description :<\/strong><\/p>\n\n\n\n
    <\/p>\n<\/blockquote>\n\n\n\n
    Ensuite on fait appel \u00e0 la fonction pour r\u00e9cup\u00e9rer les donn\u00e9es :<\/p>\n\n\n\n
    Data = recup_port_Arduino()<\/code><\/pre>\n\n\n\n
    Pour lire une ligne de donn\u00e9es, il faut utiliser la m\u00e9thode .readline()<\/strong> pour r\u00e9cup\u00e9rer chaque ligne sous forme de cha\u00eene de caract\u00e8res.<\/p>\n\n\n\n
    Ensuite, la m\u00e9thode .strip()<\/strong> permettra de supprimer les caract\u00e8res d’espacement et de tabulation en d\u00e9but et fin de cha\u00eene. <\/p>\n\n\n\n
    La m\u00e9thode .split()<\/strong> permet de s\u00e9parer les diff\u00e9rentes informations de la ligne pour les stocker dans une liste.<\/p>\n\n\n\n
    On essaie pour l’instant d’afficher une seule ligne (en utilisant .readline()<\/strong>) et la liste correspondante (avec les m\u00e9thode .strip()<\/strong> et .split()<\/strong>) :<\/p>\n\n\n\n
    line1 = Data.readline() \nprint (line1)\ndonnee=line1.strip().split()\nprint (donnee)<\/code><\/pre>\n\n\n\n
    Le r\u00e9sultat se pr\u00e9sente de la fa\u00e7on suivante :<\/p>\n\n\n\n
    b' Tension LDR: 2.65 V Courant: 2.24 mA\\r\\n'\n[b'Tension', b'LDR:', b'2.65', b'V', b'Courant:', b'2.24', b'mA']<\/code><\/pre>\n\n\n\n
    la premi\u00e8re ligne est la cha\u00eene de caract\u00e8res r\u00e9cup\u00e9r\u00e9e, et la deuxi\u00e8me ligne est une liste avec les diff\u00e9rents \u00e9l\u00e9ments de cette cha\u00eene. L’information qui nous int\u00e9resse (valeur de distance) est donc les 3\u00e8me et 6\u00e8me \u00e9l\u00e9ment de la liste … donc d’indice 2 et 5 … et oui rappelez-vous : l’indice du  premier \u00e9l\u00e9ment d’une liste est 0<\/strong> !<\/p>\n\n\n\n
    <\/p>\n\n\n\n
    \n
    Mais que veulent dire tous ces b devant les chaines de caract\u00e8res ?<\/em><\/strong><\/p>\n\n\n\n
    Ces donn\u00e9es ne sont pas vraiment des cha\u00eenes de caract\u00e8res mais des donn\u00e9es de type bytes<\/strong> (s\u00e9quences d’octet). il faudra donc les d\u00e9coder (avec la m\u00e9thode .decode() <\/strong>et \u00e9ventuellement les convertir en float <\/strong>si on a besoin de faire des calculs.<\/p>\n<\/blockquote>\n\n\n\n
    Nous pouvons choisir une acquisition pour 10 points (et de stocker les valeurs mesur\u00e9es dans les listes U et I<\/strong>) de la fa\u00e7on suivante :<\/p>\n\n\n\n
    for i in range(10) : #acquisition pour 10 valeurs\n    line = Data.readline()  # Lit la ligne venant du port s\u00e9rie.\n    print (line)\n    listeDonnees = line.strip()\n    listeDonnees = line.split() # on s\u00e9pare les donn\u00e9es de la ligne  et on les stocke dans une liste\n    print(listeDonnees)  # affichage de la liste obtenue.\n\n    if len(listeDonnees)!=0: # extraction des donn\u00e9es (valeurs d'intensit\u00e9 et tension)\n        tension = float(listeDonnees[2].decode())\n        courant = float(listeDonnees[5].decode())\n        U.append(tension)\n        print(\"U = %f\"%(tension))\n        I.append(courant)\n        print(\"I = %f\"%(courant))\n        \n    \nData.close()   # pour arr\u00eater la lecture des donn\u00e9es s\u00e9rie<\/code><\/pre>\n\n\n\n
    Quelques lignes de code suppl\u00e9mentaires pour enregistrer ces informations dans un fichier texte de format .txt<\/strong>. Cela peut \u00eatre utile pour l’importation de ces donn\u00e9es dans des logiciels ou tableurs (Latis pro, Regressi, Excel, Libre Office ,…). Le chemin est d\u00e9fini par d\u00e9faut dans le dossier o\u00f9 se trouve le fichier python mais il est possible de d\u00e9finir d’autres chemins:<\/p>\n\n\n\n
    #Ecriture dans un fichier txt\n\nfor i in range (len (I)):\n    line = str(I[i]) +'\\t'+ str(U[i])+'\\n'\n    lines.append(line)\n\nopen('data.txt', 'w').writelines(lines) #cr\u00e9ation d'un nouveau fichier texte<\/code><\/pre>\n\n\n\n
    Etape 2 : trac\u00e9 de graphe (statique ou dynamique)<\/strong><\/h2>\n\n\n\n
    Graphe statique (qui sera affich\u00e9 en fin d’acquisition)<\/h3>\n\n\n\n
    Pour tracer un graphe, il faut au pr\u00e9alable importer la biblioth\u00e8que matplotlib de la mani\u00e8re suivante :<\/p>\n\n\n\n
    import matplotlib.pyplot as plt  # pour le trac\u00e9 de graphe<\/code><\/pre>\n\n\n\n
    Nous allons utiliser la fonction stats.linregress(X,Y)<\/strong> pour faire la r\u00e9gression lin\u00e9aire. Cette fonction retourne plusieurs valeurs, les trois premi\u00e8res sont la pente, l’origine \u00e0 l’ordonn\u00e9e et le coefficient de corr\u00e9lation (\u00e0 mettre au carr\u00e9)<\/p>\n\n\n\n
    eq = stats.linregress (I,U) # pour faire la r\u00e9gression lin\u00e9aire\n\npente = eq[0] # pente\nordorig = eq[1] # ordonn\u00e9e \u00e0 l'origine\ncoeff2 = eq[2]**2 # coefficient de corr\u00e9lation au carr\u00e9 r\u00b2\n\nXcalc = np.linspace(0,max(I) , 256) # cr\u00e9ation de points pour le trac\u00e9 du mod\u00e8le : on cr\u00e9e 256 points r\u00e9guli\u00e8rement espac\u00e9s entre 0 et la valeur max de I\nYcalc = pente*Xcalc+ordorig # on fait calculer U avec les param\u00e8tres de la r\u00e9gression lin\u00e9aire pour ces valeurs de I\ntexte = 'equation de la droite  U = '+str(round(pente,3))+' I + '+str(round(ordorig,3))+'     R\u00b2 = '+str(round(coeff2,3)) # on affiche l'\u00e9quation de la droite avec 3 d\u00e9cimales\n\nprint (texte)<\/code><\/pre>\n\n\n\n
    Il suffit de taper ces quelques lignes de code pour afficher le graphe avec les valeurs stock\u00e9es dans les listes :<\/p>\n\n\n\n
    # Affichage du graphique\nplt.title('U=f(I)') # titre du graphique\nplt.scatter(I,U, color ='r', marker = 'o') # On affiche les points de coordonn\u00e9es (I,U) avec des points rouges\nplt.plot(Xcalc,Ycalc,color = 'b',label = texte) # Affichage de la courbe mod\u00e9lis\u00e9e en bleu\nplt.xlabel('I')       # nommer l'axe des abscisses\nplt.ylabel('U')       # nommer l'axe des ordonn\u00e9ees\nplt.xlim (min(I),max(I))  #limtes pour les axes avec les valeurs extr\u00eames de I et de U\nplt.ylim(min(U),max(U))\nplt.legend()   # pour afficher les l\u00e9gendes (label)\nplt.show()  #afficher le graphique (ne rien mettre dans la parenth\u00e8se)<\/code><\/pre>\n\n\n\n
    Le code complet pour le trac\u00e9 de graphe statique :<\/strong><\/p>\n\n\n\n
    \n\"\"\"\nProgramme Python pour r\u00e9cup\u00e9rer les donnn\u00e9es d'un code Arduino permettant de tracer une caract\u00e9ristique d'une photor\u00e9sistance (ou autre capteur r\u00e9sistif). On affiche ensuite les r\u00e9sultats d'une r\u00e9gression lin\u00e9aire.\nMontage : Une tension de 5 V est appliqu\u00e9e aux deux points extr\u00eames d'un potentiom\u00e8tre. On cr\u00e9e une alimentation variable en r\u00e9cup\u00e9rant la tension entre le point milieu et la masse .\nOn applique cette tension \u00e0 une association s\u00e9rie photor\u00e9sistance avec r\u00e9sistance connue (1 kohms)-. On fait mesurer par Arduino la tension aux bornes de la photor\u00e9sistance et l'intensit\u00e9 parcourant le circuit I = (tension alim - tension photor\u00e9sistance)\/R.\n\"\"\"\n\n#########################################  IMPORTATION DES BIBLIOTHEQUES ET MODULES  ########################################################\n\nimport numpy   # numpy pour les maths , par exemple pour cr\u00e9er 256 valeurs r\u00e9guli\u00e8rement espac\u00e9es entre 0 et 10 : np.linspace(0,10,256)\nfrom time import sleep             # pour faire des \"pauses\" dans l'ex\u00e9cution du programme\nimport matplotlib.pyplot as plt # pour les graphiques\n\n\nfrom scipy import stats # module permettant de faire la r\u00e9gression lin\u00e9aire \u00e0 partir d'une liste X et d'une liste Y, stats.linregress(X,Y) renvoie 5 valeurs. Les 3 premi\u00e8res valeurs sont la pente, l'ordonn\u00e9e \u00e0 l'origine, et le coefficient de corr\u00e9lation (\u00e0 mettre au carr\u00e9)\n\n\nimport serial\nimport serial.tools.list_ports\n\n\n\n#########################################  COMMUNICATION AVEC CARTE ARDUINO ET DEFINITION DES VARIABLES  #######################################################\n\n#initialisation des listes\nU=[]\nI=[]\nlines = ['I(mA)\\tU(V)\\n']\n\n\n\n# Fonction pour la r\u00e9cup\u00e9ration des donn\u00e9es s\u00e9rie venant de la carte Arduino\ndef recup_port_Arduino() :\n    ports = list(serial.tools.list_ports.comports())\n    for p in ports:\n        if 'Arduino' in p.description :\n            mData = serial.Serial(p.device,9600)\n    print(mData.is_open) # Affiche et v\u00e9rifie que le port est ouvert\n    print(mData.name) # Affiche le nom du port \n    return mData\n\n\n\n\n\n#########R\u00e9cup\u00e9ration des donn\u00e9es qu'on stocke dans des listes ########################################################################\n\nData =recup_port_Arduino() #r\u00e9cup\u00e9ration des donn\u00e9es\n\nfor i in range(10) : #acquisition pour 10 valeurs\n    line = Data.readline()  # Lit la ligne venant du port s\u00e9rie.\n    print (line)\n    listeDonnees = line.strip()\n    listeDonnees = line.split() # on s\u00e9pare les donn\u00e9es de la ligne  et on les stocke dans une liste\n    print(listeDonnees)  # affichage de la liste obtenue.\n\n    if len(listeDonnees)!=0: # extraction des donn\u00e9es (valeurs d'intensit\u00e9 et tension)\n        tension = float(listeDonnees[2].decode())\n        courant = float(listeDonnees[5].decode())\n        U.append(tension)\n        print(\"U = %f\"%(tension))\n        I.append(courant)\n        print(\"I = %f\"%(courant))\n        \n    \nData.close()\n\n#Ecriture dans un fichier txt\nfor i in range (len (I)):\n    line = str(I[i]) +'\\t'+ str(U[i])+'\\n'\n    lines.append(line)\n\nopen('data.txt', 'w').writelines(lines) #cr\u00e9ation d'un nouveau fichier texte sans la premi\u00e8re ligne\n\n\neq = stats.linregress (I,U) # pour faire la r\u00e9gression lin\u00e9aire\n\npente = eq[0] # pente\nordorig = eq[1] # ordonn\u00e9e \u00e0 l'origine\ncoeff2 = eq[2]**2 # coefficient de corr\u00e9lation au carr\u00e9 r\u00b2\n\nXcalc = numpy.linspace(0,max(I) , 256) # cr\u00e9ation de points pour le trac\u00e9 du mod\u00e8le : on cr\u00e9e 256 points r\u00e9guli\u00e8rement espac\u00e9s entre 0 et la valeur max de I\nYcalc = pente*Xcalc+ordorig # on fait calculer U avec les param\u00e8tres de la r\u00e9gression lin\u00e9aire pour ces valeurs de I\n\nglobal texte\ntexte = 'equation de la droite  U = '+str(round(pente,3))+' I + '+str(round(ordorig,3))+'     R\u00b2 = '+str(round(coeff2,3)) # on affiche l'\u00e9quation de la droite avec 3 d\u00e9cimales\n\nprint (texte)\n\n# Affichage du graphique\nplt.title('U=f(I)') # titre du graphique\nplt.scatter(I,U, color ='r', marker = 'o') # On affiche les points de coordonn\u00e9es (I,U) avec des points rouges\nplt.plot(Xcalc,Ycalc,color = 'b',label = texte) # Affichage de la courbe mod\u00e9lis\u00e9e en bleu\nplt.xlabel('I')       # nommer l'axe des abscisses\nplt.ylabel('U')       # nommer l'axe des ordonn\u00e9ees\nplt.xlim (min(I),max(I))  #limtes pour les axes avec les valeurs extr\u00eames de I et de U\nplt.ylim(min(U),max(U))\nplt.legend()   # pour afficher les l\u00e9gendes (label)\nplt.show()  #afficher le graphique (ne rien mettre dans la parenth\u00e8se)\n<\/code><\/pre>\n\n\n\n
    \n
    \n
    \"\"
    Forte luminosit\u00e9<\/figcaption><\/figure>\n\n\n\n
    \"\"
    Faible luminosit\u00e9<\/figcaption><\/figure>\n
    Trac\u00e9s avec des \u00e9clairements diff\u00e9rents<\/figcaption><\/figure>\n\n\n\n
    <\/p>\n<\/div>\n\n\n\n
    Trac\u00e9 de graphe en temps r\u00e9el (avec la fonction animate)<\/h3>\n\n\n\n
    Pour tracer un graphe \u00ab\u00a0anim\u00e9\u00a0\u00bb en temps r\u00e9el, il faut importer les modules suivants :<\/p>\n\n\n\n
    import matplotlib.pyplot as plt  # pour le trac\u00e9 de graphe\nfrom matplotlib import animation # pour la figure anim\u00e9e<\/code><\/pre>\n\n\n\n
    Nous allons inclure les instructions de la boucle dans une fonction nomm\u00e9e animate(i)<\/strong> :<\/p>\n\n\n\n
    def animate(i):\n\n    line = Data.readline()  # Lit la ligne venant du port s\u00e9rie.\n    print (line)\n    listeDonnees = line.strip()\n    listeDonnees = line.split() # on s\u00e9pare les donn\u00e9es de la ligne  et on les stocke dans une liste\n    print(listeDonnees)  # affichage de la liste obtenue.\n    while  len (U)<10 :\n        if len(listeDonnees)!=0: # extraction des donn\u00e9es (valeurs d'intensit\u00e9 et tension)\n            tension = float(listeDonnees[2].decode())\n            courant = float(listeDonnees[5].decode())\n            U.append(tension)\n            print(\"U = %f\"%(tension))\n            I.append(courant)\n            print(\"I = %f\"%(courant))\n            line0.set_data(I, U)\n            return line0,\n    \n\n\n\n<\/code><\/pre>\n\n\n\n
    Puis on r\u00e9cup\u00e8re les donn\u00e9es et on fait affchier la figure anim\u00e9e avec la m\u00e9thode animation.FuncAnimation<\/strong> :<\/p>\n\n\n\n
    \nData =recup_port_Arduino() #r\u00e9cup\u00e9ration des donn\u00e9es\n\n\n# Cr\u00e9ation figure\n\nfig=plt.figure()\nline0, = plt.plot([],[])\nplt.xlim(0, 5)\nplt.ylim(0,5)\nplt.xlabel(\"I\")\nplt.ylabel(\"U\")\n\n#Animation\nani = animation.FuncAnimation(fig, animate,  frames=21,  interval=20,repeat=False)\n\nplt.show()\nData.close()<\/code><\/pre>\n\n\n\n
    Le code complet pour le trac\u00e9 de graphe  en temps r\u00e9el :<\/strong><\/p>\n\n\n\n
    \n\"\"\"\nProgramme Python pour r\u00e9cup\u00e9rer les donnn\u00e9es d'un code Arduino permettant de tracer en temps r\u00e9el une caract\u00e9ristique d'une photor\u00e9sistance (ou autre capteur r\u00e9sistif). On affiche ensuite les r\u00e9sultats d'une r\u00e9gression lin\u00e9aire.\nMontage : Une tension de 5 V est appliqu\u00e9e aux deux points extr\u00eames d'un potentiom\u00e8tre. On cr\u00e9e une alimentation variable en r\u00e9cup\u00e9rant la tension entre le point milieu et la masse .\nOn applique cette tension \u00e0 une association s\u00e9rie photor\u00e9sistance avec r\u00e9sistance connue (1 kohms)-. On fait mesurer par Arduino la tension aux bornes de la photor\u00e9sistance et l'intensit\u00e9 parcourant le circuit I = (tension alim - tension photor\u00e9sistance)\/R.\n\"\"\"\n\n#########################################  IMPORTATION DES BIBLIOTHEQUES ET MODULES  ########################################################\n\nimport numpy   # numpy pour les maths , par exemple pour cr\u00e9er 256 valeurs r\u00e9guli\u00e8rement espac\u00e9es entre 0 et 10 : np.linspace(0,10,256)\nfrom time import sleep             # pour faire des \"pauses\" dans l'ex\u00e9cution du programme\nimport matplotlib.pyplot as plt # pour les graphiques\nimport matplotlib.animation as animation\n\nfrom scipy import stats # module permettant de faire la r\u00e9gression lin\u00e9aire \u00e0 partir d'une liste X et d'une liste Y, stats.linregress(X,Y) renvoie 5 valeurs. Les 3 premi\u00e8res valeurs sont la pente, l'ordonn\u00e9e \u00e0 l'origine, et le coefficient de corr\u00e9lation (\u00e0 mettre au carr\u00e9)\n\n\nimport serial\nimport serial.tools.list_ports\n\n\n\n#########################################  COMMUNICATION AVEC CARTE ARDUINO ET DEFINITION DES VARIABLES  #######################################################\n\nR= 1000.0 # valeur de r\u00e9sistance connue pour mesure de l'intensit\u00e9\n\n\nU_alim = 0.0\ncourant_A =0.0\nlines = ['I(mA)\\tU(V)\\n']\n\n\n# Fonction pour la r\u00e9cup\u00e9ration des donn\u00e9es s\u00e9rie venant de la carte Arduino\ndef recup_port_Arduino() :\n    ports = list(serial.tools.list_ports.comports())\n    for p in ports:\n        if 'Arduino' in p.description :\n            mData = serial.Serial(p.device,9600)\n    print(mData.is_open) # Affiche et v\u00e9rifie que le port est ouvert\n    print(mData.name) # Affiche le nom du port \n    return mData\n\n\n#########################################  Fonction animate(i) pour trac\u00e9 en temps r\u00e9el    ##############################################################################\n\n\ndef animate(i):\n\n    line = Data.readline()  # Lit la ligne venant du port s\u00e9rie.\n    print (line)\n    listeDonnees = line.strip()\n    listeDonnees = line.split() # on s\u00e9pare les donn\u00e9es de la ligne  et on les stocke dans une liste\n    print(listeDonnees)  # affichage de la liste obtenue.\n    while  len (U)<10 :\n        if len(listeDonnees)!=0: # extraction des donn\u00e9es (valeurs d'intensit\u00e9 et tension)\n            tension = float(listeDonnees[2].decode())\n            courant = float(listeDonnees[5].decode())\n            U.append(tension)\n            print(\"U = %f\"%(tension))\n            I.append(courant)\n            print(\"I = %f\"%(courant))\n            line0.set_data(I, U)\n            return line0,\n    \n\n\n\nData =recup_port_Arduino() #r\u00e9cup\u00e9ration des donn\u00e9es\n\n\n#initialisation des listes\n\nU=[]\nI=[]\n# Cr\u00e9ation figure \"dynamique\" en temps r\u00e9el\n\nfig=plt.figure()\nline0, = plt.plot([],[])\nplt.xlim(0, 5)\nplt.ylim(0,5)\nplt.xlabel(\"I\")\nplt.ylabel(\"U\")\n\n#Animation\nani = animation.FuncAnimation(fig, animate,  frames=21,  interval=20,repeat=False)\n\nplt.show()\nData.close()\n\n\neq = stats.linregress (I,U) # pour faire la r\u00e9gression lin\u00e9aire\n\npente = eq[0] # pente\nordorig = eq[1] # ordonn\u00e9e \u00e0 l'origine\ncoeff2 = eq[2]**2 # coefficient de corr\u00e9lation au carr\u00e9 r\u00b2\n\nXcalc = numpy.linspace(0,max(I) , 256) # cr\u00e9ation de points pour le trac\u00e9 du mod\u00e8le : on cr\u00e9e 256 points r\u00e9guli\u00e8rement espac\u00e9s entre 0 et la valeur max de I\nYcalc = pente*Xcalc+ordorig # on fait calculer U avec les param\u00e8tres de la r\u00e9gression lin\u00e9aire pour ces valeurs de I\n\nglobal texte\ntexte = 'equation de la droite  U = '+str(round(pente,3))+' I + '+str(round(ordorig,3))+'     R\u00b2 = '+str(round(coeff2,3)) # on affiche l'\u00e9quation de la droite avec 3 d\u00e9cimales\n\nprint (texte)\n\n# trac\u00e9 du graphe \"statique\" avec r\u00e9sultat de la r\u00e9gression lin\u00e9aire apr\u00e8s fermeture du graphe \"dynamique\"\nplt.title('U=f(I)') # titre du graphique\nplt.scatter(I,U, color ='r', marker = 'o') # On affiche les points de coordonn\u00e9es (I,U) avec des points rouges\nplt.plot(Xcalc,Ycalc,color = 'b',label = texte) # Affichage de la courbe mod\u00e9lis\u00e9e en bleu\nplt.xlabel('I')       # nommer l'axe des abscisses\nplt.ylabel('U')       # nommer l'axe des ordonn\u00e9ees\nplt.xlim (min(I),max(I))  #limtes pour les axes avec les valeurs extr\u00eames de I et de U\nplt.ylim(min(U),max(U))\nplt.legend()   # pour afficher les l\u00e9gendes (label)\nplt.show()  #afficher le graphique (ne rien mettre dans la parenth\u00e8se)\n\n\n#Ecriture dans un fichier txt\nfor i in range (len (I)):\n    line = str(I[i]) +'\\t'+ str(U[i])+'\\n'\n    lines.append(line)\n\nopen('data.txt', 'w').writelines(lines) #cr\u00e9ation d'un nouveau fichier texte sans la premi\u00e8re ligne\n\n\n<\/code><\/pre>\n\n\n\n
    Voici en vid\u00e9o ce qui se passe  : pendant l’ex\u00e9cution du programme, nous tournons r\u00e9guli\u00e8rement le potentiom\u00e8tre pour l’acqusition de 10 points et el trac\u00e9 se fait en temps r\u00e9el. Une fois la fen\u00eatre de ce graphique ferm\u00e9e, il apparait un graphe (statique) avec les r\u00e9sultats de la r\u00e9gression lin\u00e9aire.<\/p>\n\n\n\n