[ Arduino 401] Les entrées analogiques de l’Arduino

Ce premier chapitre va vous faire découvrir comment gérer des tensions analogiques avec votre carte Arduino. Vous allez d’abord prendre en main le fonctionnement d’un certain composant essentiel à la mise en forme d’un signal analogique, puis je vous expliquerai comment vous en servir avec votre Arduino. Rassurez-vous, il n’y a pas besoin de matériel supplémentaire pour ce chapitre ! 😉

Un signal analogique : petits rappels

Faisons un petit rappel sur ce que sont les signaux analogiques. D’abord, jusqu’à présent nous n’avons fait qu’utiliser des grandeurs numériques binaires. Autrement dit, nous n’avons utilisé que des états logiques HAUT et BAS. Ces deux niveaux correspondent respectivement aux tensions de 5V et 0V. Cependant, une valeur analogique ne se contentera pas d’être exprimée par 0 ou 1. Elle peut prendre une infinité de valeurs dans un intervalle donné. Dans notre cas, par exemple, la grandeur analogique pourra varier aisément de 0 à 5V en passant par 1.45V, 2V, 4.99V, etc. Voici un exemple de signal analogique, le très connu signal sinusoïdal :

On retiendra que l’on ne s’occupe que de la tension et non du courant, en fonction du temps.

Si on essaye de mettre ce signal (ce que je vous déconseille de faire) sur une entrée numérique de l’Arduino et qu’on lit les valeurs avec digitalRead(), on ne lira que 0 ou 1. Les broches numériques de l’Arduino étant incapable de lire les valeurs d’un signal analogique.

Signal périodique

Dans la catégorie des signaux analogiques et même numériques (dans le cas d’horloge de signal pour le cadencement des micro-contrôleurs par exemple) on a les signaux dits périodiques. La période d’un signal est en fait un motif de ce signal qui se répète et qui donne ainsi la forme du signal. Prenons l’exemple d’un signal binaire qui prend un niveau logique 1 puis un 0, puis un 1, puis un 0, …

La période de ce signal est le motif qui se répète tant que le signal existe. Ici, c’est le niveau logique 1 et 0 qui forme le motif. Mais cela aurait pu être 1 1 et 0, ou bien 0 1 1, voir 0 0 0 1 1 1, les possibilités sont infinies ! Pour un signal analogique, il en va de même. Reprenons le signal de tout à l’heure :

Ici le motif qui se répète est « la bosse de chameau » ou plus scientifiquement parlant : une période d’un signal sinusoïdal. :mrgreen: Pour terminer, la période désigne aussi le temps que met un motif à se répéter. Si j’ai une période de 1ms, cela veut dire que le motif met 1ms pour se dessiner complètement avant de commencer le suivant. Et en sachant le nombre de fois que se répète le motif en 1 seconde, on peut calculer la fréquence du signal selon la formule suivante : \(F = \frac 1 T\) ; avec F la fréquence, en Hertz, du signal et T la période, en seconde, du signal.

Notre objectif

L’objectif va donc être double. Tout d’abord, nous allons devoir être capables de convertir cette valeur analogique en une valeur numérique, que l’on pourra ensuite manipuler à l’intérieur de notre programme. Par exemple, lorsque l’on mesurera une tension de 2,5V nous aurons dans notre programme une variable nommée « tension » qui prendra la valeur 250 lorsque l’on fera la conversion (ce n’est qu’un exemple). Ensuite, nous verrons avec Arduino ce que l’on peut faire avec les signaux analogiques. Je ne vous en dis pas plus…

Les convertisseurs analogiques – > numérique ou CAN

Qu’est-ce que c’est ?

C’est un dispositif qui va convertir des grandeurs analogiques en grandeurs numériques. La valeur numérique obtenue sera proportionnelle à la valeur analogique fournie en entrée, bien évidemment. Il existe différentes façons de convertir une grandeur analogique, plus ou moins faciles à mettre en œuvre, plus ou moins précises et plus ou moins onéreuses. Pour simplifier, je ne parlerai que des tensions analogiques dans ce chapitre.

La diversité

Je vais vous citer quelques types de convertisseurs, sachez cependant que nous n’en étudierons qu’un seul type.

  • Convertisseur à simple rampe : ce convertisseur « fabrique » une tension qui varie proportionnellement en un cours laps de temps entre deux valeurs extrêmes. En même temps qu’il produit cette tension, il compte. Lorsque la tension d’entrée du convertisseur devient égale à la tension générée par ce dernier, alors le convertisseur arrête de compter. Et pour terminer, avec la valeur du compteur, il détermine la valeur de la grandeur d’entrée. Malgré sa bonne précision, sa conversion reste assez lente et dépend de la grandeur à mesurer. Il est, de ce fait, peu utilisé.
  • Convertisseur flash : ce type de convertisseur génère lui aussi des tensions analogiques. Pour être précis, il en génère plusieurs, chacune ayant une valeur plus grande que la précédente (par exemple 2V, 2.1V, 2.2V, 2.3V, etc.) et compare la grandeur d’entrée à chacun de ces paliers de tension. Ainsi, il sait entre quelle et quelle valeur se trouve la tension mesurée. Ce n’est pas très précis comme mesure, mais il a l’avantage d’être rapide et malheureusement cher.
  • Convertisseur à approximations successives : Pour terminer, c’est ce convertisseur que nous allons étudier…

Arduino dispose d’un CAN

Vous vous doutez bien que si je vous parle des CAN, c’est qu’il y a une raison. Votre carte Arduino dispose d’un tel dispositif intégré dans son cœur : le micro-contrôleur. Ce convertisseur est un convertisseur « à approximations successives ». Je vais détailler un peu plus le fonctionnement de ce convertisseur par rapport aux autres dont je n’ai fait qu’un bref aperçu de leur fonctionnement (bien que suffisant).

Ceci rentre dans le cadre de votre culture générale électronique, ce n’est pas nécessaire de lire comment fonctionne ce type de convertisseur. Mais je vous recommande vivement de le faire, car il est toujours plus agréable de comprendre comment fonctionnent les outils qu’on utilise ! 🙂

Principe de dichotomie

La dichotomie, ça vous parle ? Peut-être que le nom ne vous dit rien, mais il est sûr que vous en connaissez le fonctionnement. Peut-être alors connaissez-vous le jeu « plus ou moins » en programmation ? Si oui alors vous allez pouvoir comprendre ce que je vais expliquer, sinon lisez le principe sur le lien que je viens de vous donner, cela vous aidera un peu. La dichotomie est donc une méthode de recherche conditionnelle qui s’applique lorsque l’on recherche une valeur comprise entre un minimum et un maximum. L’exemple du jeu « plus ou moins » est parfait pour vous expliquer le fonctionnement. Prenons deux joueurs. Le joueur 1 choisit un nombre compris entre deux valeurs extrêmes, par exemple 0 et 100. Le joueur 2 ne connait pas ce nombre et doit le trouver. La méthode la plus rapide pour que le joueur 2 puisse trouver quel est le nombre choisi par le joueur 1 est :

Je le disais, le joueur 2, pour arriver le plus rapidement au résultat, doit choisir une méthode rapide. Cette méthode, vous l’aurez deviné, consiste à couper en deux l’espace de recherche. Au début, cet espace allait de 0 à 100, puis au deuxième essai de 40 à 100, au troisième essai de 40 à 80, etc.

Cet exemple n’est qu’à titre indicatif pour bien comprendre le concept.

En conclusion, cette méthode est vraiment simple, efficace et rapide ! Peut-être l’aurez-vous observé, on est pas obligé de couper l’espace de recherche en deux parties égales.

Le CAN à approximations successives

On y vient, je vais pouvoir vous expliquer comment il fonctionne. Voyez-vous le rapport avec le jeu précédent ? Pas encore ? Alors je m’explique. Prenons du concret avec une valeur de tension de 3.36V que l’on met à l’entrée d’un CAN à approximations successives (j’abrégerai par CAN dorénavant).

Notez le symbole du CAN qui se trouve juste au-dessus de l’image. Il s’agit d’un « U » renversé et du caractère #.

Cette tension analogique de 3.36V va rentrer dans le CAN et va ressortir sous forme numérique (avec des 0 et 1). Mais que se passe-t-il à l’intérieur pour arriver à un tel résultat ? Pour que vous puissiez comprendre correctement comment fonctionne ce type de CAN, je vais être obligé de vous apprendre plusieurs choses avant.

Le comparateur

Commençons par le comparateur. Comme son nom le laisse deviner, c’est quelque chose qui compare. Ce quelque chose est un composant électronique. Je ne rentrerai absolument pas dans le détail, je vais simplement vous montrer comment il fonctionne.

Comparer, oui, mais quoi ?

Des tensions ! 😀 Regardez son symbole, je vous explique ensuite…

Vous observez qu’il dispose de deux entrées \(E_1\) et \(E_2\) et d’une sortie \(S\). Le principe est simple :

  • Lorsque la tension \(E_1 > E_2\) alors \(S = +V_{cc}\) (\(+V_{cc}\) étant la tension d’alimentation positive du comparateur)
  • Lorsque la tension \(E_1 < E_2\) alors \(S = -V_{cc}\) (\(-V_{cc}\) étant la tension d’alimentation négative, ou la masse, du comparateur)
  • \(E_1 = E_2\) est une condition quasiment impossible, si tel est le cas (si on relie \(E_1\) et \(E_2\)) le comparateur donnera un résultat faux

Parlons un peu de la tension d’alimentation du comparateur. Le meilleur des cas est de l’alimenter entre 0V et +5V. Comme cela, sa sortie sera soit égale à 0V, soit égale à +5V. Ainsi, on rentre dans le domaine des tensions acceptées par les micro-contrôleurs et de plus il verra soit un état logique BAS, soit un état logique HAUT. On peut réécrire les conditions précédemment énoncées comme ceci :

  • \(E_1 > E_2\) alors \(S = 1\)
  • \(E_1 < E_2\) alors \(S = 0\)
  • \(E_1 = E_2\), alors \(S = indefini\)

Simple n’est-ce pas ?

Le démultiplexeur

Maintenant, je vais vous parler du démultiplexeur. C’est en fait un nom un peu barbare pour désigner un composant électronique qui fait de l’aiguillage de niveaux logiques (il en existe aussi qui font de l’aiguillage de tensions analogiques). Le principe est là encore très simple. Le démultiplexeur à plusieurs sorties, une entrée et des entrées de sélection :

  • \(E\) est l’entrée où l’on impose un niveau logique 0 ou 1.
  • Les sorties \(S\) sont là où se retrouve le niveau logique d’entrée. UNE seule sortie peut être active à la fois et recopier le niveau logique d’entrée.
  • Les entrées \(A\) permettent de sélectionner quelle sera la sortie qui est active. La sélection se fait grâce aux combinaisons binaires. Par exemple, si je veux sélectionner la sortie 4, je vais écrire le code 0100 (qui correspond au chiffre décimal 4) sur les entrées \(A_1\) à \(A_4\)

Je rappelle que, pour les entrées de sélection, le bit de poids fort est \(A_4\) et le bit de poids faible \(A_1\). Idem pour les sorties, \(S_1\) est le bit de poids faible et \(S_{10}\), le bit de poids fort.

La mémoire

Ce composant électronique sert simplement à stocker des données sous forme binaire.

Le convertisseur numérique analogique

Pour ce dernier composant avant l’acte final, il n’y a rien à savoir si ce n’est que c’est l’opposé du CAN. Il a donc plusieurs entrées et une seule sortie. Les entrées reçoivent des valeurs binaires et la sortie donne le résultat sous forme de tension.

Fonctionnement global

Rentrons dans les explications du fonctionnement d’un CAN à approximations successives. Je vous ai fait un petit schéma rassemblant les éléments précédemment présentés :

Voilà donc comment se compose le CAN. Si vous avez compris le fonctionnement de chacun des composants qui le constituent, alors vous n’aurez pas trop de mal à suivre mes explications. Dans le cas contraire, je vous recommande de relire ce qui précède et de bien comprendre et rechercher sur internet de plus amples informations si cela vous est nécessaire.

En premier lieu, commençons par les conditions initiales :

  • \(V_e\) est la tension analogique d’entrée, celle que l’on veut mesurer en la convertissant en signal numérique.
  • La mémoire contient pour l’instant que des 0 sauf pour le bit de poids fort (\(S_{10}\)) qui est à 1. Ainsi, le convertisseur numérique – > analogique va convertir ce nombre binaire en une tension analogique qui aura pour valeur 2.5V.
  • Pour l’instant, le démultiplexeur n’entre pas en jeu.

Suivons le fonctionnement étape par étape : Étape 1 :

  • J’applique une tension \(V_e = 3.5100V\) précisément.
  • Le comparateur compare la tension \(V_{comp} = 2.5V\) à la tension \(V_e = 3.5100V\). Étant donné que \(V_e > V_{comp}\), on a un Niveau Logique 1 en sortie du comparateur.
  • Le multiplexeur entre alors en jeux. Avec ses signaux de sélections, il va sélectionner la sortie ayant le poids le plus élevé, soit \(S_{10}\).
  • La mémoire va alors enregistrer le niveau logique présent sur la broche \(S_{10}\), dans notre cas c’est 1.

Étape 2 :

  • Au niveau de la mémoire, on change le deuxième bit de poids fort (mais moins fort que le premier) correspondant à la broche \(S_9\) en le passant à 1.
  • En sortie du CNA, on aura alors une tension de \(3.75V\)
  • Le comparateur compare, il voit \(V_{comp} > V_e\) donc il donne un état logique 0.
  • La mémoire enregistre alors le niveau sur la broche \(S_9\) qui est à 0.

Étape 3 : redondante aux précédentes

  • On passe le troisième bit le plus fort (broche \(S_8\)) à 1.
  • Le CNA converti le nombre binaire résultant en une tension de \(3.125V\).
  • Le comparateur voit \(V_e > V_{comp}\), sa sortie passe à 1.
  • La mémoire enregistre l’état logique de la broche \(S_8\) qui est à 1.

Le CAN continue de cette manière pour arriver au dernier bit (celui de poids faible). En mémoire, à la fin de la conversion, se trouve le résultat. On va alors lire cette valeur binaire que l’on convertira ensuite pour l’exploiter. Bon, j’ai continué les calculs à la main (n’ayant pas de simulateur pour le faire à ma place), voici le tableau des valeurs :

Poids du bit NL en sortie du comparateur Bits stockés en mémoire Tension en sortie du convertisseur CNA (en V)
10 1 1 2.5
9 0 0 3.75
8 1 1 3.125
7 1 1 3.4375
6 0 0 3.59375
5 0 0 3.515625
4 1 1 3.4765625
3 1 1 3.49609375
2 1 1 3.505859375
1 0 0 3.5107421875

Résultat : Le résultat de la conversion donne :

Résultat de conversion (binaire) Résultat de conversion (décimale) Résultat de conversion (Volts)
1011001110 718 3,505859375

Observez la précision du convertisseur. Vous voyez que la conversion donne un résultat (très) proche de la tension réelle, mais elle n’est pas exactement égale. Ceci est dû au pas du convertisseur.

Pas de calcul du CAN

Qu’est-ce que le pas de calcul ? Eh bien il s’agit de la tension minimale que le convertisseur puisse « voir ». Si je mets le bit de poids le plus faible à 1, quelle sera la valeur de la tension \(V_{comp}\) ? Le convertisseur a une tension de référence de 5V. Son nombre de bit est de 10. Donc il peut « lire » : \(2^{10}\) valeurs pour une seule tension. Ainsi, sa précision sera de : \(\frac{5}{2^{10}} = 0,0048828125 V\) La formule à retenir sera donc :

\(\frac{V_{ref}}{2^N}\)

Avec :

  • \(V_{ref}\) : tension de référence du convertisseur
  • \(N\) : nombre de bit du convertisseur

Il faut donc retenir que, pour ce convertisseur, sa précision est de \(4.883mV\). Donc, si on lui met une tension de \(2mV\) par exemple sur son entrée, le convertisseur sera incapable de la voir et donnera un résultat égal à 0V.

Les inconvénients

Pour terminer avant de passer à l’utilisation du CNA avec Arduino, je vais vous parler de ses inconvénients. Il en existe trois principaux :

  • la plage de tension d’entrée : le convertisseur analogique de l’Arduino ne peut recevoir à son entrée que des tensions comprises entre 0V et +5V. On verra plus loin comment améliorer la précision du CAN.
  • la précision : la précision du convertisseur est très bonne sauf pour les deux derniers bits de poids faible. On dit alors que la précision est de \(\pm 2 LSB\) (à cause du pas de calcul que je viens de vous expliquer).
  • la vitesse de conversion : le convertisseur N/A de la carte Arduino n’a pas une très grande vitesse de conversion par rapport à un signal audio par exemple. Ainsi , si l’on convertit un signal audio analogique en numérique grâce à la carte Arduino, on ne pourra entendre que les fréquences en dessous de 10kHz. Dans bien des cas cela peut être suffisant, mais d’en d’autre il faudra utiliser un convertisseur A/N externe (un composant en plus) qui sera plus rapide afin d’obtenir le spectre audio complet d’un signal sonore.

Lecture analogique, on y vient…

Lire la tension sur une broche analogique

Un truc très sympa avec Arduino, c’est que c’est facile à prendre en main. Et ça se voit une fois de plus avec l’utilisation des convertisseurs numérique – > analogique ! En effet, vous n’avez qu’une seule nouvelle fonction à retenir : analogRead() !

analogRead(pin)

Cette fonction va nous permettre de lire la valeur lue sur une entrée analogique de l’Arduino. Elle prend un argument et retourne la valeur lue :

  • L’argument est le numéro de l’entrée analogique à lire (explication ci-dessous)
  • La valeur retournée (un int) sera le résultat de la conversion analogique- >numérique

Sur une carte Arduino Uno, on retrouve 6 CAN. Ils se trouvent tous du même côté de la carte, là où est écrit « Analog IN » :

Analog IN

Ces 6 entrées analogiques sont numérotées, tout comme les entrées/sorties logiques. Par exemple, pour aller lire la valeur en sortie d’un capteur branché sur le convertisseur de la broche analogique numéro 3, on fera : valeur = analogRead(3);.

Ne confondez pas les entrées analogiques et les entrées numériques ! Elles ont en effet le même numéro pour certaines, mais selon comment on les utilise, la carte Arduino saura si la broche est analogique ou non.

Mais comme nous sommes des programmeurs intelligents et organisés, on nommera les variables proprement pour bien travailler de la manière suivante :

Convertir la valeur lue

Bon c’est bien, on a une valeur retournée par la fonction comprise entre 0 et 1023, mais ça ne nous donne pas vraiment une tension ça ! Il va être temps de faire un peu de code (et de math) pour convertir cette valeur… Et si vous réfléchissiez un tout petit peu pour trouver la solution sans moi ? :mrgreen: … Trouvée ?

Conversion

Comme je suis super sympa je vais vous donner la réponse, avec en prime : une explication ! Récapitulons. Nous avons une valeur entre 0 et 1023. Cette valeur est l’image de la tension mesurée, elle-même comprise entre 0V et +5V. Nous avons ensuite déterminé que le pas du convertisseur était de 4.88mV par unité. Donc, deux méthodes sont disponibles :

  • avec un simple produit en croix
  • en utilisant le pas calculé plus tôt

Exemple : La mesure nous retourne une valeur de 458.

  • Avec un produit en croix on obtient : \(\frac{458\times 5}{1023} = 2.235V\)
  • En utilisant le pas calculé plus haut on obtient : \(458\times 4.88 = 2.235V\)

Les deux méthodes sont valides, et donnent les mêmes résultats. La première à l’avantage de faire ressortir l’aspect « physique » des choses en utilisant les tensions et la résolution du convertisseur.

Voici une façon de le traduire en code :

Mais il n’existe pas une méthode plus « automatique » que faire ce produit en croix ?

Eh bien SI ! En effet, l’équipe Arduino a prévu que vous aimeriez faire des conversions facilement et donc une fonction est présente dans l’environnement Arduino afin de vous faciliter la tâche ! Cette fonction se nomme map(). À partir d’une valeur d’entrée, d’un intervalle d’entrée et d’un intervalle de sortie, la fonction vous retourne la valeur équivalente comprise entre le deuxième intervalle. Voici son prototype de manière plus explicite :

Prenons notre exemple précédent. La valeur lue se nomme « valeurLue ». L’intervalle d’entrée est la gamme de la conversion allant de 0 à 1023. La gamme (ou intervalle) de « sortie » sera la tension réelle à l’entrée du micro-contrôleur, donc entre 0 et 5V. En utilisant cette fonction nous écrirons donc :

Pourquoi tu utilises 5000mV au lieu de mettre simplement 5V ?

Pour la simple et bonne raison que la fonction map utilise des entiers. Si j’utilisais 5V au lieu de 5000mV j’aurais donc seulement 6 valeurs possibles pour ma tension (0, 1, 2, 3, 4 et 5V). Pour terminer le calcul, il sera donc judicieux de rajouter une dernière ligne :

Au retour de la liaison série (seulement si on envoie les valeurs par la liaison série) on aurait donc (valeurs à titre d’exemple) :

On est moins précis que la tension calculée plus haut, mais on peut jouer en précision en modifiant les valeurs de sortie de la fonction map(). Ou bien garder le calcul théorique et le placer dans une « fonction maison ».

Exemple d’utilisation

Le potentiomètre

Qu’est-ce que c’est que cette bête-là encore ?

Le potentiomètre (ou « potar » pour les (très) intimes) est un composant très fréquemment employé en électronique. On le retrouve aussi sous le nom de résistance variable. Comme ce dernier nom l’indique si bien, un potentiomètre nous permet entre autres de réaliser une résistance variable. En effet, on retrouve deux applications principales que je vais vous présenter juste après. Avant toute chose, voici le symbole du potentiomètre :

symbole potentiomètre

Cas n°1 : le pont diviseur de tension

On y remarque une première chose importante, le potentiomètre a trois broches. Deux servent à borner les tensions maximum (A) et minimum (B) que l’on peut obtenir à ses bornes, et la troisième (C) est reliée à un curseur mobile qui donne la tension variable obtenue entre les bornes précédemment fixées. Ainsi, on peut représenter notre premier cas d’utilisation comme un « diviseur de tension réglable ». En effet, lorsque vous déplacez le curseur, en interne cela équivaut à modifier le point milieu. En termes électroniques, vous pouvez imaginer avoir deux résistances en série (R1 et R2 pour être original). Lorsque vous déplacez votre curseur vers la borne basse, R1 augmente alors que R2 diminue et lorsque vous déplacez votre curseur vers la borne haute, R2 augmente alors que R1 diminue. Voici un tableau montrant quelques cas de figure de manière schématique :

Schéma équivalent Position du curseur Tension sur la broche C
50/50 Curseur à la moitié \(V_{signal} = (1-\frac{50}{100})\times 5 = 2.5 V\)
25/75 Curseur à 25% du départ \(V_{signal} = (1-\frac{25}{100})\times 5 = 3.75 V\)
75/25 Curseur à 75% du départ \(V_{signal} = (1-\frac{75}{100})\times 5 = 1.25 V\)

Si vous souhaitez avoir plus d’informations sur les résistances et leurs associations ainsi que sur les potentiomètres, je vous conseille d’aller jeter un œil sur ce chapitre. 😉

Cas n°2 : la résistance variable

Le deuxième cas d’utilisation du potentiomètre est la résistance variable. Cette configuration est très simple, il suffit d’utiliser le potentiomètre comme une simple résistance dont les bornes sont A et C ou B et C. On pourra alors faire varier la valeur ohmique de la résistance grâce à l’axe du potentiomètre.

Attention, il existe des potentiomètres linéaires (la valeur de la tension évolue de manière proportionnelle au déplacement du curseur), mais aussi des potentiomètres logarithmique/anti-logarithmique (la valeur de la tension évolue de manière logarithmique ou anti-logarithmique par rapport à la position du curseur). Choisissez-en dont un qui est linéaire si vous souhaitez avoir une proportionnalité.

Utilisation avec Arduino

Vous allez voir que l’utilisation avec Arduino n’est pas vraiment compliquée. Il va nous suffire de raccorder les alimentations sur les bornes extrêmes du potentiomètre, puis de relier la broche du milieu sur une entrée analogique de la carte Arduino :

potar schémapotar montage

Une fois le raccordement fait, nous allons faire un petit programme pour tester cela. Ce programme va simplement effectuer une mesure de la tension obtenue sur le potentiomètre, puis envoyer la valeur lue sur la liaison série (ça nous fera réviser :mrgreen: ). Dans l’ordre, voici les choses à faire :

  • – Déclarer la broche analogique utilisée (pour faire du code propre)
  • – Mesurer la valeur
  • – L’afficher !

Je vous laisse chercher ? Aller, au boulot ! 😈 … Voici la correction, c’est le programme que j’ai fait, peut-être que le vôtre sera mieux :

Vous venez de créer votre premier Voltmètre ! 😀

Une meilleure précision ?

Est-il possible d’améliorer la précision du convertisseur ?

Voilà une question intéressante à laquelle je répondrai qu’il existe deux solutions plus ou moins faciles à mettre en œuvre.

Solution 1 : modifier la plage d’entrée du convertisseur

C’est la solution la plus simple ! Voyons deux choses…

Tension de référence interne

Le micro-contrôleur de l’Arduino possède plusieurs tensions de référence utilisables selon la plage de variation de la tension que l’on veut mesurer. Prenons une tension, en sortie d’un capteur, qui variera entre 0V et 1V et jamais au delà. Par défaut, la mesure se fera entre 0 et 5V sur 1024 niveaux (soit une précision de 4.88 mV). Ce qui veut dire qu’on aura seulement les 204 premiers niveaux d’utiles puisque tout le reste correspondra à plus d’un volt. Pour améliorer la précision de lecture, on va réduire la plage de mesure d’entrée du convertisseur analogique – > numérique en réduisant la tension de référence utilisée (initialement 5V). Pour cela, rien de matériel, tout se passe au niveau du programme puisqu’il y a une fonction qui existe : analogReference(). Cette fonction prend en paramètre le nom de la référence à utiliser :

  • DEFAULT : La référence de 5V par défaut (ou 3,3V pour les cartes Arduino fonctionnant sous cette tension, telle la Due)
  • INTERNAL : Une référence interne de 1.1V (pour la Arduino Uno)
  • INTERNAL1V1 : Comme ci-dessus mais pour la Arduino Mega
  • INTERNAL2V56 : Une référence de 2.56V (uniquement pour la Mega)
  • EXTERNAL : La référence sera celle appliquée sur la broche ARef

Dans notre cas, le plus intéressant sera de prendre la valeur INTERNAL pour pouvoir faire des mesures entre 0 et 1.1V. Ainsi, on aura 1024 niveaux ce qui nous fera une précision de 1.07mV. C’est bien meilleur ! Le code est à placer dans la fonction setup() de votre programme :

Tension de référence externe

Maintenant que se passe t’il si notre mesure devait être faite entre 0 et 3V ? On ne pourrait plus utiliser INTERNA1V1 puisqu’on dépasse les 1.1V. On risquerais alors de griller le comparateur. Dans le cas d’une Arduino Mega, on ne peut pas non plus utiliser INTERNAL2V56 puisqu’on dépasse les 2.56V. Nous allons donc ruser en prenant une référence externe à l’aide de la valeur EXTERNAL comme ceci :

Ensuite, il ne restera plus qu’à apporter une tension de référence supérieur à 3V sur la broche ARef de la carte pour obtenir notre nouvelle référence.

Astuce : la carte Arduino produit une tension de 3.3V (à côté de la tension 5V). Vous pouvez donc utiliser cette tension directement pour la tension de référence du convertisseur. 😉 Il suffit pour cela de relier avec un fil la sortie indiquée 3.3V à l’entrée AREF.

Attention cependant, la tension maximale de référence ne peut être supérieure à +5V et la minimale inférieure à 0V. En revanche, toutes les tensions comprises entre ces deux valeurs sont acceptables.

Mais, si je veux que ma tension d’entrée puisse varier au-delà de +5V, comment je fais ? Y a-t-il un moyen d’y parvenir ? o_O

Oui, voyez ce qui suit…

Schéma du pont diviseur de tension

Solution 2 : utiliser un pont diviseur de tension

Nous avons vu cela à la partie précédente avec le potentiomètre. Il s’agit en fait de diviser votre signal par un certain ratio afin de l’adapter aux contraintes d’entrées du convertisseur. Par exemple, imaginons que nous ayons une mesure à faire sur un appareil qui délivre une tension comprise entre 0 et 10V. Cela ne nous arrange pas puisque nous ne sommes capable de lire des valeurs qu’entre 0 et 5V. Nous allons donc diviser cette mesure par deux afin de pouvoir la lire sans risque. Pour cela, on utilisera deux résistances de valeur identique (2 fois \(10 k\Omega\) par exemple) pour faire un pont diviseur de tension. La tension à mesurer rentre dans le pont (\(U\) sur le schéma ci-contre) et la tension mesurable sort au milieu du pont (tension \(U_s\)). Il ne reste plus qu’à connecter la sortie du pont à une entrée analogique de la carte Arduino et lire la valeur de la tension de sortie.

Libre à vous de modifier les valeurs des résistances du pont diviseur de tension pour faire rentrer des tensions différentes (même au delà de 10V !). Attention cependant à ne pas dépasser les +5V en sortie du pont !

Solution 3 : utiliser un CAN externe

La deuxième solution consisterait simplement en l’utilisation d’un convertisseur analogique – > numérique externe. A vous de choisir le bon. Il en existe beaucoup, ce qu’il faut principalement regarder c’est :

  • la précision (10 bits pour Arduino, existe d’autre en 12bits, 16bits, …)
  • la vitesse d’acquisition (celui d’Arduino est à une vitesse de 100µs)
  • le mode de transfert de la lecture (liaison série, I²C, …)
  • le nombre d’entrées (6 sur Arduino Uno)
  • la tension d’entrée maximale et minimale (max +5V et min 0V)

Au programme :

  • Le prochain chapitre est un TP faisant usage de ces voies analogiques
  • Le chapitre qui le suit est un chapitre qui vous permettra de créer des tensions analogiques avec votre carte Arduino, idéal pour mettre en œuvre la deuxième solution d’amélioration de la précision de lecteur du convertisseur !

En somme, ce chapitre vous a permis de vous familiariser un peu avec les tensions analogiques, ce qui vous permettra par la suite de gérer plus facilement les grandeurs renvoyées par des capteurs quelconques.

76 commentaires

  1. bonjour! très bien expliqué! Merci! Je suis en train de développer un projet dans lequel je mesure la température extérieure, j’affiche sur LCD, je déclenche un relais à moins de 15C. Mon problème c’est: mon voltage sur A0 fluctue et le relais se met à  »clicker » avec les variations de voltage jusqu’a se stabiliser. Comment je pourrait résoudre ce problème? Merci!

    voici mon code:

    #include
    LiquidCrystal lcd(12, 11, 6, 5, 4, 3); //Define los pines para el LCD

    float centi()
    {
    int dato;
    float c;
    dato=analogRead(A0);

    c = (500 * dato)/1023;

    return(c);

    }

    float fahren(float cent)

    {

    float f;
    f= cent*1.8 + 32;

    return f;

    }
    //Declare variables
    float tempC;
    int tempPin = 0; // Sensor de temperatura conectado al pin 0
    int ledPin = 13; // led conectado al pin 13
    int fan1 =7; // Motor conectado al pin 7
    //Escribir funcion Setup

    void setup() {
    // put your setup code here, to run once:

    Serial.begin(9600); // Abre el puerto serie para comunicar con el
    pinMode (ledPin,OUTPUT);
    pinMode (fan1, OUTPUT);
    //Primera serie
    lcd.begin(16,2);
    lcd.print(« C= « );
    lcd.setCursor (0,1);
    lcd.print(« F= « );

    // Escritura del código de loop que controlará el
    //funcionamiento del motor al llegar a una temperatura determinada

    }

    void loop() {
    // put your main code here, to run repeatedly:

    tempC = analogRead(tempPin); //Toma la lectura de la temperatura
    tempC = (5.0*tempC*100.0)/1024.0; //Conversión del input análogo en valor

    Serial.print((byte)tempC);

    if (tempC >30)
    {
    digitalWrite(ledPin, HIGH);
    digitalWrite(fan1, HIGH);

    }
    else
    {
    digitalWrite(ledPin, LOW);
    digitalWrite(fan1, LOW);

    //segunda parte loop affichage
    float Centigrados = centi();
    float Fahrenheit = fahren(Centigrados);

    lcd.setCursor(2,0);
    lcd.print(Centigrados);

    lcd.setCursor(2,1);
    lcd.print(Fahrenheit);

    lcd.setCursor(10,1);

    delay(5000);
    }
    //delay (3000);
    }

    • Ce problème d’oscillation est bien connu et possède sa solution : l’hystérésis. Pour faire simple, on ne va pas utiliser un seul seuil, mais deux !

      Si on considère deux états, ON et OFF. Il faut être a ON si temp est supérieur a 30 et OFF sinon. Le problème comme tu l’as remarque c’est que lorsqu’on sera autour de 30, on aura un coup un peu au dessus et un peu au dessous a cause de la précision du capteur. Pour cela, on va considérer qu’on passer a OFF seulement en dessous de 28 par exemple et on passera a ON seulement au dessus de 30. Il y aura alors une zone indéfini de 2 degrés ou il ne se passera rien et la broche gardera son état précédent et n’oscillera plus.

    • Pas forcement, ce peut-être simplement des parasites qui traînent dans l’air (il y a beaucoup de choses qui traînent, entre les ondes wifi, les câbles électriques a droite a gauche etc…). La valeur mesurée ne doit pas trop grande tout de même ?!

      • Bonjour, pour commencer super tuto que j’ai pris plaisir a le lire 🙂
        Après, j’ai le même problème, à vide, sur chaque entrée analogique j’ai une mesure comprise entre 300 et 350. Et cella me pose énormément problème car quand mon capteur est branché, il renvoie une valeur qui est très proche de celle si.
        Et dans mon programme je ne peut pas vérifier si j’ai quelque chose est connecté sur mes entrée analogique comme j’aimerais faire.
        Pour résoudre mon problème, j’ai branché les entrée que je n’utilise pas sur la masse, mais c’est un peu une solution tirer par les cheveux ^^ Aurais tu une autre solution ?
        Merci d’avance,

        Cordialement.

          • Merci, alors j’ai fait avec un analogReference(INTERNAL);
            Et toujours le même problème, sans rien de brancher sur ma carte Arduino il m’envoie une valeur proche de celle que je mesure avec mon capteur…

          • Et si la valeur envoyé par le capteur est mesurée avec un multimètre on obtient quelque chose de cohérent ?

            (sinon changer la référence ne résout pas la suppression du parasite, mais j’avais espoir que ça augmente la différence entre le signal utile et le bruit constant)

  2. Salut, très bon tuto pour les débutants. J’ai une petite question :
    J’essaye de brancher une sonde de courant TT 100-SD (100A max et out 33,33mA) sur l’Arduino, Faut-il un schéma de câblage particulier ? Un pont diviseur ? ou une simple résistance de 33Ohms suffit pour avoir une tension comprise entre 0 et 5V
    J’utilise l’Arduino en tant que CAN.

    Merci d’avance,

    Cordialement.

    • C’est une bonne question… Je n’ai jamais utilise de tel capteur et la doc n’est pas très bavarde… Quel est le type de signal de sortie en fonction du courant mesuré ? Si tu veux je te conseille d’ouvrir un sujet sur Zeste de Savoir dans la catégorie « Systèmes et Matériel », des membres comme zeqL devrait pouvoir t’aider bien plus précisément que je ne le ferais je pense 🙂

  3. D’abord, merci pour ton blog très instructif.

    Ensuite, comment faire pour mesurer des tensions supérieure à 5V en utilisant ta méthode et sans matériel supplémentaire ? Je voudrai mesurer un tension comprise entre 0V et 20V… merci d’avance 🙂

    • J’ai lu l’article en entier (enfin presque, parce qu’il est long…) et me suis aperçu qu’il fallait utiliser un pont diviseur de tension…
      ch’tite question: si je fait un circuit avec juste des résistances entre mes bornes + et – ça ne crée pas un court-circuit ?

  4. Bonjour, et tout d’abord très bon travail et très bien expliquer cependant je me poses quelques questions :
    -Quand on fait le calcul à la main ValeurLue * 5 / 1024 cela nous donne des V non ??
    -Dans la ligne 28 (du voltmètre) Serial.print(tension,2); je ne comprend pas le 2 c’est lui qui va l’afficher on est d’accords ? il faudra écrire Serial.print(tension);

    • -Quand on fait le calcul à la main ValeurLue * 5 / 1024 cela nous donne des V non ??

      Yep.

      Dans la ligne 28 (du voltmètre) Serial.print(tension,2); je ne comprend pas le 2 c’est lui qui va l’afficher on est d’accords ? il faudra écrire Serial.print(tension);

      Le 2 sert simplement a indiquer combien de chiffres après la virgule nous souhaitons envoyer.

      • heu salut c’est encore moi, ya un souci car chez moi le « 2 » dans « Serial.print(tension,2); » ne correspond pas du tout aux virgules, après un petit test je me rend compte qu’il correspond à la base.Si je met « Serial.print(tension,2); » j’obtiens un nombre en base 2, si je met un 3 a la place j’obtiens un nombre en base 3 etc…

        En plus de ça je me rend compte que ma carte arduino ne calcule pas correctement: j’utilise la formule (x*5000)/1023 pour obtenir la tension, sauf que j’obtiens des nombres incorrectes, parfois même négatifs.

        Je sais pas si c’est moi qui ai loupé un épisode ou si c’est ma carte qui a un soucis, je vais ouvrir un sujet dans zeste de savoir comme tu me l’a demandé.

        merci et bonne continuation.

  5. Un autre code trés simple qui affiche juste la tension 😉

    int potar = 0;
    float tension;
    int valeurlue;

    void setup()
    {
    pinMode(potar, INPUT);
    Serial.begin(9600);
    }

    void loop()
    {
    valeurlue = analogRead(potar);
    tension = valeurlue * (5.0 / 1024);

    Serial.println(« VOLTS »);

    Serial.println(tension,2);
    delay(1000);
    }

  6. Bonsoir, excellent tuto. À vue de nez, serait-il possible d’utiliser un signal AC venant d’un anémomètre (produisant sa propre tension en tournant et elle est lue après redressement (je crois) sur un cadran galvanomètre) en entrée analogique et, en sortie digitale, d’utiliser la tension obtenue pour allumer des leds en « bargraph » indiquant la vitesse du vent (comme pour un vu-mètre de haut-parleur) ?

  7. bonjour vraiment super le tuto merci, mon projet de fin d’étude c’est un appareil auditif en fait le principe c’est de diviser en 6 bandes de fréquences un signal audio grâce à des filtres passes bandes qu’on a fabriquer et tout mon problème c’est comment faire varier le gain de chaque signal filtrer et cela grâce à arduino je voudrais savoir si c’est possible et comment je pourrais faire. merci d’avance ^^

  8. Bonjour, si je peux me permettre de chipoter, le calcul de conversion tension= valeurlue*(5/1024) est assurément faux. La lecture se faisant du bit 0 au bit 1023, en appliquant 5v sur l’input on obtient 1023*(5/1024) ce qui ne fait pas 5. il faut diviser par 1023 et non pas par 1024 (eh oui problème d’intervalle !). Bon! une erreur de 5/1000, c’est inférieur à la précision de l’arduino mais cela pourrait poser des problèmes dans des calculs plus complexes notamment avec un pont diviseur en entrée pouvant déboucher sur une erreur de plusieurs volts.
    A part cette coquille, bravo pour la didactique de l’article

  9. s’il vous je veux réaliser un ampèremètre à base de ca3161-2 j’ai essayer de varier le potentiomètre qui sert à mettre 000 dans les afficheurs mais ça marche pas ça stabilise pas y a t-elle de solution?????

    • Salut !

      Quel rapport avec l’Arduino ? Je ne connais pas particulièrement ces composants, mais en lisant les doc. techniques a priori il suffit de bien brancher le 3161 avec le 3162 et sélectionner le bit a afficher sur ce dernier pour que cela marche non ? Pour en parler plus en details je te propose de venir expliquer ton probleme en creant un sujet sur le forum « Systèmes et Matériel » de Zeste de Savoir 🙂

  10. Bonjour,
    tout d’abord merci pour ce super tuto 😉

    Je rencontre une difficulté lors d’un programme arduino et j’aimerais savoir comment faire pour y remédier 😉
    Je dispose d’un bras de robot avec sur chaque moteur un potentiomètre. J’aimerais lire la valeur d’un potentiomètre relié à un moteur puis faire tourner le moteur jusqu’à ce que la valeur du potentiomètre arrive à la valeur souhaitée. Seulement le moteur tourne sans s’arrêter même lorsqu’il à dépassé la valeur indiquée.
    Je vous montre le programme :

    Tout d’abord avec un autre programme je lis la valeur analogique du potentiomètre du moteur en question. Puis je lis la valeur du potentiomètre lorsque le moteur est à l’endroit finale où je souhaite qu’il aille. Ici, sa valeur est de 500 en position initiale et de 107 en position finale :

    int moteur3s0 = 10;
    int moteur3s1 = 11;
    const int potard = A1;

    void setup() {

    pinMode(moteur3s0, OUTPUT);
    pinMode(moteur3s1, OUTPUT);

    }

    void loop() {

    int valpotard = analogRead(potard);

    while (valpotard > 107) {
    digitalWrite(moteur3s1, HIGH);
    valpotard = analogRead(potard);
    }

    }

    voilà, merci de bien vouloir m’aider,
    cordialement.

    • Oups^^
      désolé de vous avoir dérangé pour rien, juste après avoir cliqué sur  » laisser un commentaire « , la solution m’est apparu de manière totalement évidente x)

      Il suffisait juste à la fin de la boucle de dire au moteur de s’arrêter, et mon programme fonctionne !!!

      Merci encore et désolé du commentaire inutile….

  11. bonjour,

    Merci pour votre réponse favorable.

    Bref, j’ai une carte arduino uno, un servodrive et un servomoteur. je veux faire varier la vitesse de mon Moteur en augmentant ou diminuant la fréquence d’impulsion issue de la carte vers le servodrive.

    est ce que vous avez une idée comment agir pour augmenter la fréquence de sortie de la carte?

    Merci pour votre coopération,

  12. Bonjour,
    j’ai ètulisè dans mon projet un capteur de radiation a base d’arduino et ethernet shield,j’ai recu les valeurs de radiation .mais comment les recevoir dans le temps rèel par exemple l’exècution affiche:
    8:12:54 11/05/2015 la valeur de radiation est = 740
    8:13:54 11/05/2015 la valeur de radiation est = 500
    …..

  13. L’article laisse penser qu’on peut à loisir passer d’une référence à une autre: INTERNAL ,DEFAULT (VRef) ou EXTERNAL. Ce n’est pas le cas: si le pin ARef est connecté, on ne peut plus utiliser INTERNAL et DEFAULT (datasheet p.243) :
    « If the user has a fixed voltage source connected to the AREF pin, the user may not use the other reference
    voltage options in the application, as they will be shorted to the external voltage. If no external voltage is applied
    to the AREF pin, the user may switch between AV CC and 1.1V as reference selection. »

    Par ailleurs, l’article affirme qu’une tension ADC supérieure à la tension de référence pourrait «griller le comparateur». C’est faux: la tension n’est pas un problème, du moment que l’ampérage est limité. Le document officiel « AVR182: Zero Cross Detector » montre que l’on peut tout à fait connecter directement du 240V au pin de l’ADC (via une résistance d’1MΩ) sans «griller le comparateur».

      • Merci.
        J’ai fait une erreur dans la seconde partie: le « zero cross detector » utilise le pin PD2/INT0 et non pas l’ADC contrairement à mon souvenir. Aussi, bien qu’il mentionne la possibilité de connecter jusqu’à 1000V sans dommage sur les diodes (toujours avec une résistance d’1MΩ), rien ne dit dans ce document que le comparateur puisse le supporter.

  14. hello my name is Mohamed I’m 20 I’m a student I have a project to end studies. I didunposte measure the pressure and flow with reported de4-20ma arduino but déficilefor me was programming for and what you can help me to give a program to work

    • Hello Mohamed.

      As I can’t write everybody’s program, I can’t help you too much. However, I would advise you to create a thread in some forum like arduino.cc and I’m sure people will gladly help you to solve your problem ! 🙂

  15. Attention il y a une erreur de calcul pour le traitement de la valeur numérique.
    il est énonce:

    valeurLue = analogRead(uneBrocheAvecUnCapteur);
    //produit en croix, ATTENTION, donne un résultat en mV !
    tension = valeurLue * 4.88;
    //formule à aspect « physique », donne un résultat en mV !
    tension = valeurLue * (5 / 1023);

    Alors que le deuxième calcul exprime le résultat en V et non en mV!!
    En effet,
    5/1023=0.00488=4.88m et non 4.88

  16. Merci pour tout ton tuto, c’est vraiment très bien fait !

    J’ai un projet en cours, l’arduino servant à surveiller les tensions de sortie d’une alimentation 15V symétrique. Le pond diviseur me parait indispensable pour passer de 15V à 5V … mais je me demandais si il avait une astuce autre qu’un AOP pour mesurer une tension négative.(peut être envisagerai tu de rajouter ce point au tuto).

    bien cordialement,

  17. je suis nouveau sur ce site et sur le développement arduino, je realise une carte a l’aide de 2 capteurs analogique Lm393 light sensor, et MQ5 pour qualité d’aire ( taux de CO2)
    ce tuto m’a vraiment aidé pour la conversion en volt mais je me bloque pour la conversion en Lux (unité de la luminosité) et la conversion en pourcentage pour la qualité d’air…
    je sais que les valeurs sont de 0 à 1023 mais je ne sais pas ça correspond a quoi en plage de lux.
    svp qq1 peut m’aider c urgnet et merci a vous tous

  18. salut j’ai encore un souci car chez moi le “2” dans “Serial.print(tension,2);” ne correspond pas du tout aux virgules, après un petit test je me rend compte qu’il correspond à la base.Si je met “Serial.print(tension,2);” j’obtiens un nombre en base 2, si je met un 3 a la place j’obtiens un nombre en base 3 etc…

    En plus de ça je me rend compte que ma carte arduino ne calcule pas correctement: j’utilise la formule (x*5000)/1023 pour obtenir la tension, sauf que j’obtiens des nombres incorrectes, parfois même négatifs.Pour l’exercice avec le potentiomètre voila mon code et des résultats que j’obtiens:

    code:

    int pinanalogique=0;
    int valeurinitiale=0;
    int tension=0;

    void setup()
    {
    Serial.begin(9600);
    Serial.println(« demarrage »);
    }

    void loop()
    {
    valeurinitiale = analogRead(pinanalogique);//fonction permettant de lire une voie analogique

    tension = (( 5000*valeurinitiale )/1023);//on converti la
    //valeur sur la pin analogique (qui est une valeur comprise entre 0 et 1023)
    //en tension

    Serial.println(« valeur initiale: »);
    Serial.println(valeurinitiale);

    Serial.println(« tension: »);
    Serial.println(tension);//on afffiche la valeur obtenu toute les sec
    delay(1000);
    }

    Résultats sur le moniteur série:

    valeur initiale:
    0
    tension:
    0
    valeur initiale:
    72
    tension:
    31
    valeur initiale:
    186
    tension:
    12
    valeur initiale:
    301
    tension:
    -2
    valeur initiale:
    457
    tension:
    -8
    valeur initiale:
    589
    tension:
    -4
    valeur initiale:
    671
    tension:
    12
    valeur initiale:
    670
    tension:
    7

    merci et bonne continuation.

    • pour le « Serial.print(tension,2); » j’ai fini par comprendre, c’est que les int ne contiennent pas de décimaux.Mais pour les gros calculs du genre 5000*5000 je comprend toujours pas pourquoi les résultat sont faux (même si je stock le résultat dans un long).

      • parce que le compilateur est « idiot ». Il voit deux int, alors il veut stocker dans un int qu’il convertira ensuite en long (mais ce sera trop tard). Pour faire correctement il faut caster un des deux en long comme ceci par exemple : long resultat = (long) gros_int * encore_un_int;

  19. je suis dans le 29amateur de voiliers RC naviguants:
    Une problématique;
    Bonjour,
    Meilleurs vœux,
    Je cherche, depuis assez longtemps, le moyen de commander un moteur 6 volts DC à charbons ;
    Ce circuit électronique fera se déplacer un point quelconque* (x) situé sur la périphérie d’une poulie à gorge montée sur la sortie du treuil en sens horaire, contre horaire, ou le maintient en position fixe.
    Il s’agit de me fabriquer un treuil costaud et rapide pour réglages des voiles sur un….voilier…. RC.
    J’ai donc le récepteur de ma RC qui donne les ordres transmis par l’émetteur, un moteur, un réducteur (cascade de pignons),une poulie à gorge sur l’axe de sortie du réducteur un potentiomètre de recopie multi tours (bürns) des ponts en H.
    Il faut :
    1. Avoir une course angulaire variable par PROGRAMMATION « des buttées , end point…… » dans une plage de 0 à 6 fois 360° en sortie de réducteur
    2. Commander , DANS cette plage (limites, bornes, ….) de rotation, le déplacement de ce point* en sens trigo ou anti-trigo via le manche de commande des gaz de l’émetteur
    3. Maintenir la position de (x) quand on n’actionne pas la commande de gaz
    4. Si ce point (x), venait à se déplacer sans ordre de l’émetteur, qu’il retrouve la position ci-dessus établie
    5. Mais que le moteur ne chauffe pas anormalement, ne tremble pas ; risque d’endommager le circuit, le moteur carrément de mettre feux à l’embarcation ; et je ne dis pas la consommation . donc la zone neutre doit être ni trop faible ni trop forte !
    Si on le veut, voir souhaitable en finalisation de l’engin, on y rajoute quelques alarmes et sécurités ;
    • Faible voltage de l’accumulateur de réception (il sert aussi à l’alimentation des servo)
    Action : émission d’un son par un mini buzzer embarqué et on pousse un peu, basculement automatique de la tension en 4,8 V (commande BEC ?) afin de pouvoir finir une manche avec un treuil plus lent et moins de couple ; et on complique, si télémétrie : information à l’émetteur de l’état de charge de l’accu embarqué ainsi que de ce mode économique , voire les nouvelles performances sous ce voltage afin que cela ne ce mete en sécurité suivante, savoir:
    • Chauffe anormale du moteur (blocage mécanique dans circuit mécanique ou écoutes embrouillée ne passant plus les passes coque, « surpatage » au niveau de la gorge de poulie, tout simplement trop d’effort demandé
    Action : émission d’un son par mini buzzer et mise en sécurité du treuil en définissant un point médian où restera le treuil permettant ainsi le retours au rivage
    Si l’on possède une radio non programmable, pouvoir entrer ces paramètres par fil ; Muni d’une cosse, on pourrait le brancher au récepteur sur une voie de libre et par un nombre d’impulsions envoyé sur cette voie par l’émetteur (exemple, stick de gauche commande la voie d’’un canal non occupé, on branche le fil sur cette sotie canal du récepteur et donc faire l’envoi de ces impulsions), ou alors par USB et ordi (avec un programme qui va avec) ou encore une mini carte de programmation Ou simplement nombre d’impulsions de courrant via un bête bouton poussoir ?
    Le mini buzzer aura un code de son (par nombre, duré, tonalités) qui pourra informer l’utilisateur des mises en sécurité ainsi que de la programmation ; une ou deux leds peuvent compléter le tout…….
    Mais comme je l’ai dit, ces sécurité , voire programmation, sont un peaufinage du treuil ; on peut très bien définir la course du treuil, point haut, point bas ) par le réglage de petits potentiomètres, la sécurité de chauffe (due généralement à une demande d’effort trop importante), peut être gérée archaïquement par un ressort qui ferait que la poulie ne soit plus entrainée au delà d’une certaine pression de ce ressort (genre glissement réglable, dé crabotage….)
    Au fait, j’ai oublié de vous dire que je possède des Arduino Nano (quelle version, je sais pas) dans un fond de tiroir. Peut être ce micro contrôleur pourrait être utile à ces fins? Par contre, je n’ai aucune formation Arduino, j’’essaie, tant bien , plutôt mal, de m’y mettre par internet et les nombreux sites consacrés….. Ou alors, perles rares, existent des circuits tout faits que l’on pourrait dévier de leur usage normal?
    En espérant, ici, avoir une solution autre que celle de m’acheter un RMG et autre produits des sites italiens. J’aime le compliqué, du moins au départ. Je précise bien que ce n’est nullement destiné à une utilisation à fin commerciale, ce n’est pas mon but et si il existait, et bien je me payerai les services d’une personne compétente 🙂
    Merci encore de votre plus qu’aide, si vous le désirer. Cordiales salutations ;
    Bertrand

    Autre chose, il faut que le moteur ne tremble pas en statique sous effort normal: que la zone de neutre fasse en sorte d’être bien calculée (ou réglable?):sinon chauffe moteur, consommation élevée, risque de cramer l’électronique ,plus de parasites électronique; ce qui est très fréquent quand les potentiomètres de l’émetteur voir les commande mécaniques de ces dernier ne sont pas soignés ( la précision d’un ensemble électronique, comme d’autres secteurs, sera toujours limité par la qualité moindre d’un seul des composants…

    • Bonjour,

      J aimerai avec une carte SDC ( arduino par exemple ) réaliser un voltemetre d une résolution de au moins 10^-4 mV et de bonne précision aussi de l ordre 1-5 % . Ma plage de mesure se situe entre 25 mV et 0. Pensez-vous que cela soit possible sur un CAN externe a l arduino ? Connaissez vous des CAN avec de telle caractéristique? –

  20. Bonjour,

    Les entrées numériques de l’arduino sont limité à combien de bits ? Par exemple est ce que l’arduino est capable de lire le nombre « 1024 » en bits ? Mais est-il capable de lire « 2^18 » en bits ?

    Ma question n’a peut-être pas de sens …

    Merci !

    • Je suppose que tu veux parler des entrées « analogiques » (car une entrée numérique ne peut prendre que 0 ou 1 comme valeur). Les convertisseurs analogiques de l’Arduino ont une résolution de 10 bits, donc peuvent convertir une tension sur une plage de 2^10 valeurs (0 à 1023).

  21. Bonjour, tout d’abord merci pour tes tutos. ☺ J’ai un problème sur la lecture d’une entrée analogique d’un signal provenant d’un télémètre infrarouge sharp gp2d12. Et je ne comprends pas ce qui peut se passer. Quand mon arduino uno est branché en usb et que c’est lui qui alimente le capteur je reçois bien un signal cohérent (champ dégagé = très faible tension ~0,20v) mais quand je l’alimente par un 7805 pour rendre autonome mon montage, l’arduino voit en permanence un minimum de ~1,2v quand l’arduino est branché au pc, et la valeur augmente à ~1,7v quand je le debranche du pc (tout le monde est alimenté par le 7805). Le pire c’est que même si je n’ai plus de capteur il y a quand même la même tension lue sur l’entrée analogique (!) … C’est à n’y rien comprendre 😞. Aurais-tu une idée ? 😃

  22. Bonjour;
    Bravo et merci pour ce blog;

    J’ai une petite question au sujet de votre montage du potentiomètre sur l’Arduino (pour la lecture des tensions).
    Il me semble que branché en direct entre le + et la masse comme vous le présentez, c’est un peu risqué pour la carte non ?
    Que se passe-t-il si l’utilisateur passe le potentiomètre à 0 ohms pendant quelques minutes ? (j’ai pas osé m’y aventurer).

    Merci d’avance

    • Et non, il n’y a pas de souci car il y a toujours « l’intégralité » de la résistances entre le 5V et la masse. En effet, on ne fait que se « déplacer » le long de la résistance, mais aucun courant ne part dans l’Arduino et donc pas de court-circuit. Je ne sais pas si je suis très clair dans mon commentaire…

      Si on déplace le potentiomètre à fond d’un coté, alors on mesurera 5V. Si on le déplace à fond de l’autre côté alors on mesurera 0V. Mais dans tout les cas il y aura toujours l’intégralité de la résistance entre +5V et la masse.

      • Bonjour Eskimon;

        Effectivement c’est évident… La question était stupide;
        Il n’y avait donc qu’une seule chose de réellement utile dans mon post : « merci et bravo pour ce blog » 😉
        Je renouvelle donc le compliment.

        Merci encore !

  23. Bonsoir, merci pour le tuto.
    Je voulais réaliser un compteur pour la gestion de l’électricité mais puisqu’on a pas encore fais le cours sur les microcontrolleurs, alors j’ai du mal à savoir comment m’y prendre pour y faire entrer une tension sinusoïdale ( c’est à dire les 220VAC qu’on ne peut pas directement injecter au niveau du microcontrolleur ) et comment recueillir cette tension à la sortie pour alimenter les appareils domestiques.
    Please, j’ai besoin de cette explication puisque je ne peux pas attendre qu’on fasse le cours pour pour réaliser mon projet.

    • Hello,

      Si j’ai bien compris ce que tu recherche tu vas devoir passer par un relais, il va faire le pont entre ton arduino et la tension 230V.

      Je crois que le mieux est d’ajouter également un optocoupleur entre ton Arduino et ton relais, ceci afin de protéger totalement l’arduino de la tension 230V.

  24. Bonjour, j’ai un soucis de consommation par la pin analogique lorsque l’arduino n’est pas alimenté.

    J’utilise l’arduino, pour surveiller une installation photovoltaique, l’arduino est alimenté par l’onduleur lorsqu’il y a du soleil. J’ai une pile 3V en secours de la surveillance, elle alimente une alarme locale.
    Je souhaiterais mesurer la tension de cette pile pour savoir quand la remplacer. L’entrée analogique fonctionne très bien lorsque l’arduino est alimenté, mais la nuit, lorsque l’arduino n’est pas alimenté, un courant de 28 mA circule de la pile vers la pin A0 de l’arduino. Bilan, la pile se vide en quelques jours !!!
    Comment réduire le courant entrant dans une pin analogique lorsque l’arduino n’est pas alimenté ?

    Merci d’avance pour votre retour.

  25. Bonjour Eskimon et merci pour toutes ces infos.

    3 questions me viennent :
    Tu présente un CAN dans le cours, mais au final sur l’arduino, on revient à un CNA. Du coup je suis un peu perdu

    Quel est l’intérêt du potentiomètre dans l’exemple à la fin de ton cours ?
    J’ai du mal à voir ce que l’on va en faire, et surtout comment l’on règle la résistance du potentiomètre.

    Deuxièmement, selon moi le « loop » va renvoyer chaque fois la même valeur à chaque itération puisqu’on ne modifie jamais la valeur du potentiomètre ?

    Merci beaucoup !

    Et enfin pour la valeur

  26. Bonsoir, merci pour le tuto, il est bien expliqué.

    Outre que le problème fréquent de bruit j’ai un autre problème. Mon projet consiste à lire une tension sinusoïdale de faible valeur sur un pin analogique et tracer sa courbe sur un PC que je fais sous labview (traçage du courbe). Le problème c’est que si on est dans les basses fréquences tout va bien et le signal apparaît un peu bruité mais dés que j’augmente la fréquences je perds le signal et j’ai une autre forme du signal totalement différente. Que faire alors ?

    Cordialement.

  27. Pingback: BTS SN 2EME ANNEE | Pearltrees

  28. Pingback: Variation de vitesse de moteur continu avec un arduino - La programmation sur le web

  29. Bonjour Eskimon,
    J’apprécie vraiment votre blog, je voudrais savoir si le programme fonctionnera si l’on remplace le mot potar à la ligne 2 par le mot grove ?.
    Ensuite, à la ligne 6 je voudrais savoir que signifie float.
    Enfin, je voudrais savoir pourquoi on démarre une liaison série et à quoi sa sert ?

Laisser un commentaire