{"id":1433,"date":"2024-09-10T06:07:21","date_gmt":"2024-09-10T04:07:21","guid":{"rendered":"https:\/\/labopothier.com\/?p=1433"},"modified":"2024-09-27T14:26:32","modified_gmt":"2024-09-27T12:26:32","slug":"activite-arduino-python-trace-de-caracteristique-dune-photoresistance-avec-codes-arduino-et-codes-python-equivalent","status":"publish","type":"post","link":"https:\/\/labopothier.com\/index.php\/2024\/09\/10\/activite-arduino-python-trace-de-caracteristique-dune-photoresistance-avec-codes-arduino-et-codes-python-equivalent\/","title":{"rendered":"ACTIVITE ARDUINO\/PYTHON : Trac\u00e9 de caract\u00e9ristique d&rsquo;une photor\u00e9sistance (avec codes Arduino et codes Python \u00e9quivalent)"},"content":{"rendered":"\n<p><strong>Remarque<\/strong> : Cette activit\u00e9 peut \u00eatre programm\u00e9e avec le langage d&rsquo;Arduino mais aussi en Python. Pour cela, il faut utiliser Nanpy (voir l&rsquo;article <a rel=\"noreferrer noopener\" href=\"https:\/\/labopothier.com\/index.php\/2020\/04\/04\/programmer-en-python-pour-la-carte-arduino\/\" target=\"_blank\">Programmer-en-python-pour-la-carte-arduino<\/a>)<\/p>\n\n\n\n<p><strong>Objectif : <\/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&nbsp; 1k\u03a9).<\/p>\n\n\n\n<figure class=\"wp-block-image size-large\"><img loading=\"lazy\" decoding=\"async\" width=\"1024\" height=\"317\" src=\"https:\/\/labopothier.com\/wp-content\/uploads\/2020\/04\/trace_caracteristique-1024x317.png\" alt=\"\" class=\"wp-image-360\" srcset=\"https:\/\/labopothier.com\/wp-content\/uploads\/2020\/04\/trace_caracteristique-1024x317.png 1024w, https:\/\/labopothier.com\/wp-content\/uploads\/2020\/04\/trace_caracteristique-300x93.png 300w, https:\/\/labopothier.com\/wp-content\/uploads\/2020\/04\/trace_caracteristique-768x238.png 768w, https:\/\/labopothier.com\/wp-content\/uploads\/2020\/04\/trace_caracteristique.png 1417w\" sizes=\"auto, (max-width: 1024px) 100vw, 1024px\" \/><\/figure>\n\n\n\n<p><strong>Bonus<\/strong> : Faire une r\u00e9gression lin\u00e9aire en utilisant le module <strong>&nbsp;linregress <\/strong>(en important le module <strong>stats<\/strong> de <strong>scipy<\/strong>).<\/p>\n\n\n\n<p><strong>Remarque&nbsp;<\/strong>: manipulation peut-\u00eatre un peu trop compliqu\u00e9e.&nbsp;Il vaudrait mieux faire un montage \u00e9lectrique classique (sans microcontr\u00f4leur) et mesurer les valeurs de I (avec un amp\u00e8rem\u00e8tre) et U aux bornes de la photor\u00e9sistance (avec un voltm\u00e8tre) en utilisant une alimentation variable.&nbsp;<\/p>\n\n\n\n<p>On pourrait ensuite utiliser le programme Python<strong> Trac\u00e9 caracteristique U=f(I) avec regression lineaire <\/strong>en inscrivant les valeurs mesur\u00e9es dans des listes.<\/p>\n\n\n\n<pre title=\"Avec le langage Arduino\" class=\"wp-block-code\"><code lang=\"cpp\" class=\"language-cpp line-numbers\">\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( U_alim &lt; 5.0)\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  Serial.print(\"Fin de la session de mesures\");\/\/ Affiche de fin de mesure\n\n  \n  while(1);           \n}<\/code><\/pre>\n\n\n\n<pre title=\"Avec le langage Python (en utilisant Nanpy)\" class=\"wp-block-code\"><code lang=\"python\" class=\"language-python line-numbers\"># -*- coding: utf-8 -*-\n\"\"\"\nProgramme Python pour trac\u00e9 caract\u00e9ristique d'une photor\u00e9sistance (ou autre capteur r\u00e9sistif).\nUne 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-r\u00e9sistance connue (1 kiloohm). 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  ########################################################\nfrom nanpy import ArduinoApi        # importation des biblioth\u00e8ques pour communication avec Arduino\nfrom nanpy import SerialManager\n\nimport numpy as np  # 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\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\n#########################################  COMMUNICATION AVEC CARTE ARDUINO ET DEFINITION DES BROCHES ET VARIABLES  #######################################################\n\nR= 1000.0 # valeur de r\u00e9sistance connue pour mesure de l'intensit\u00e9\nconnection = SerialManager(device='COM7') #renseigner le bon port utilis\u00e9 par la carte Arduino\n\na = ArduinoApi(connection=connection) #connection \u00e0 la carte Arduino, on pr\u00e9c\u00e9dera chaque instruction Arduino par \n                                      # a. (exemple a.pinMode(2,a.OUTPUT)\n\n\nbroche_LDR = 0 #Tension aux bornes de la photor\u00e9sistance, selon la version de nanpy il faut indiquer 0 ou A.0\nbroche_alim =1 # Tension entre le point milieu du potentiom\u00e8tre et la masse (tension de l'alimentation variable), \n                # selon la version de nanpy il faut indiquer 1 ou A.1\n\nU=[]\nI=[]\nU_alim = 0.0\ncourant_A =0.0\n\n\n#########################################  ACQUISITION  AVEC ARDUINO EN LANGAGE PYTHON     ##############################################################################\n\nwhile U_alim &lt; 5.0 : # on agit sur le potentiom\u00e8tre pour faire varier la tension U_alim de 0 \u00e0 5V, une mesure sera faite toutes les 2 secondes. D\u00e8s que la tension maximale est atteinte, le programme s'arr\u00eate\n\n    Valeur_alim = a.analogRead(broche_alim) # lecture de la tension U_LDR par la carte Arduino (valeur comprise entre 0 et 1023)\n    U_alim = float(Valeur_alim *5.0\/1023) # conversion pour r\u00e9cup\u00e9rer la valeur de la tension\n\n    Valeur_LDR   = a.analogRead(broche_LDR) # lecture de la tension U_alim par la carte Arduino (valeur comprise entre 0 et 1023)\n    U_LDR_mesure = float(Valeur_LDR*5.0\/1023) # conversion pour r\u00e9cup\u00e9rer la valeur de la tension\n\n    courant_A   = (U_alim - U_LDR_mesure)\/R # pour r\u00e9cup\u00e9rer la valeur de l'intensit\u00e9 du courant dans le circuit \n                                            # (loi d'Ohm)\n    I.append(courant_A) # On  met la valeur de l'intensit\u00e9 dans la liste I\n    U.append (U_LDR_mesure) # On  met la valeur de la tension U_LDRdans la liste U\n\n    print ('I :',I)\n    print('U photor\u00e9sistance : ',U) # pour afficher les listes au fur et \u00e0 mesure de l'acqusition\n    sleep(2)\n\n#################################   REGRESSION LINEAIRE ET TRACE DE GRAPHIQUE ########################################################################################\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 = 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)\n\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","protected":false},"excerpt":{"rendered":"<p>Remarque : Cette activit\u00e9 peut \u00eatre programm\u00e9e avec le langage d&rsquo;Arduino mais aussi en Python. Pour cela, il faut utiliser Nanpy (voir l&rsquo;article Programmer-en-python-pour-la-carte-arduino) Objectif : 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&nbsp; 1k\u03a9). Bonus : [&hellip;]<\/p>\n","protected":false},"author":1,"featured_media":1556,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"site-sidebar-layout":"default","site-content-layout":"default","ast-site-content-layout":"default","site-content-style":"default","site-sidebar-style":"default","ast-global-header-display":"","ast-banner-title-visibility":"","ast-main-header-display":"","ast-hfb-above-header-display":"","ast-hfb-below-header-display":"","ast-hfb-mobile-header-display":"","site-post-title":"","ast-breadcrumbs-content":"","ast-featured-img":"","footer-sml-layout":"","ast-disable-related-posts":"","theme-transparent-header-meta":"default","adv-header-id-meta":"","stick-header-meta":"","header-above-stick-meta":"","header-main-stick-meta":"","header-below-stick-meta":"","astra-migrate-meta-layouts":"set","ast-page-background-enabled":"default","ast-page-background-meta":{"desktop":{"background-color":"var(--ast-global-color-4)","background-image":"","background-repeat":"repeat","background-position":"center center","background-size":"auto","background-attachment":"scroll","background-type":"","background-media":"","overlay-type":"","overlay-color":"","overlay-opacity":"","overlay-gradient":""},"tablet":{"background-color":"","background-image":"","background-repeat":"repeat","background-position":"center center","background-size":"auto","background-attachment":"scroll","background-type":"","background-media":"","overlay-type":"","overlay-color":"","overlay-opacity":"","overlay-gradient":""},"mobile":{"background-color":"","background-image":"","background-repeat":"repeat","background-position":"center center","background-size":"auto","background-attachment":"scroll","background-type":"","background-media":"","overlay-type":"","overlay-color":"","overlay-opacity":"","overlay-gradient":""}},"ast-content-background-meta":{"desktop":{"background-color":"var(--ast-global-color-5)","background-image":"","background-repeat":"repeat","background-position":"center center","background-size":"auto","background-attachment":"scroll","background-type":"","background-media":"","overlay-type":"","overlay-color":"","overlay-opacity":"","overlay-gradient":""},"tablet":{"background-color":"var(--ast-global-color-5)","background-image":"","background-repeat":"repeat","background-position":"center center","background-size":"auto","background-attachment":"scroll","background-type":"","background-media":"","overlay-type":"","overlay-color":"","overlay-opacity":"","overlay-gradient":""},"mobile":{"background-color":"var(--ast-global-color-5)","background-image":"","background-repeat":"repeat","background-position":"center center","background-size":"auto","background-attachment":"scroll","background-type":"","background-media":"","overlay-type":"","overlay-color":"","overlay-opacity":"","overlay-gradient":""}},"footnotes":""},"categories":[7,10],"tags":[],"class_list":["post-1433","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-microcontroleurs-et-python","category-programmer-une-carte-arduino-avec-python"],"_links":{"self":[{"href":"https:\/\/labopothier.com\/index.php\/wp-json\/wp\/v2\/posts\/1433","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/labopothier.com\/index.php\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/labopothier.com\/index.php\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/labopothier.com\/index.php\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/labopothier.com\/index.php\/wp-json\/wp\/v2\/comments?post=1433"}],"version-history":[{"count":4,"href":"https:\/\/labopothier.com\/index.php\/wp-json\/wp\/v2\/posts\/1433\/revisions"}],"predecessor-version":[{"id":1579,"href":"https:\/\/labopothier.com\/index.php\/wp-json\/wp\/v2\/posts\/1433\/revisions\/1579"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/labopothier.com\/index.php\/wp-json\/wp\/v2\/media\/1556"}],"wp:attachment":[{"href":"https:\/\/labopothier.com\/index.php\/wp-json\/wp\/v2\/media?parent=1433"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/labopothier.com\/index.php\/wp-json\/wp\/v2\/categories?post=1433"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/labopothier.com\/index.php\/wp-json\/wp\/v2\/tags?post=1433"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}