MicroPython-Hack-Analogique

Ce que nous faisons

.: Mesure de tension analogique :.

En plus de ses broches digitales, PyBoard dispose aussi de 16 broches qui peuvent être utilisées comme entrées analogiques. Ces entrées acceptent une tension (de 0 à 3.3 volts) et la converti en un nombre entier allant de 0 (0 volts) à 4095 (3.3 volts) avec une résolution de 12 bits. Un dispositif très utile qui exploite ces entrées est le potentiomètre (aussi appelé résistance variable).

Lorsque les broches extérieures du potentiomètre sont alimentées avec 3.3volts, la broche du milieu permet de lire une valeur entre 0 et 3.3 volts, valeur dépendant de l'angle avec lequel le potentiomètre est tourné (ex : 1.65 volts à mi-course). Nous pouvons alors utiliser la valeur retournée comme une variable de notre programme.

Vous pouvez facilement identifier les broches analogiques sur le diagramme car elles sont marquées comme ADC.

Crédit: MicroPython micropython.org

Le montage

Le matériel nécessaire

Fils

disponible chez MCHobby

Résistance de 100 Ohms (brun-noir-brun)
x1

disponible chez MCHobby

LED (ou DEL)
x1

disponible chez MCHobby

Potentiomètre 10K Ohms
x1

disponible chez MCHobby

 

Tous ces éléments sont disponibles sur shop.mchobby.be.

Schéma

Montage

Le code

Lecture analogique simple

Voici un petit bout de code que vous pouvez tester en mode REPL. Il lit et affiche 10 fois l'entrée analogique.

pot = pyb.ADC( 'X19' )
for i in range( 0, 10 ):
    print( pot.read() )
    pyb.delay( 1000 )

Vous obtiendrez un résultat similaire à celui-ci (en bougeant le potentiomètre bien entendu).

4092
4095
4090
4093
3265
3266
3265
3264
3265
3265

Potentiomètre vers PWM

Le programme suivant lit la valeur sur l'entrée analogique et module la luminosité de la LED en fonction de la position du potentiomètre.

Tournez le potentiomètre pour modifier la luminosité de la LED.

# Lecture analogique pour controler la puissance d'une LED PWM.
# ATTENTION: échantillonnage 12 Bits (valeur de 0 à 4096)
from pyb import Timer, delay

adc = pyb.ADC(pyb.Pin.board.X19)    # Créer ADC sur la broche  X19

# Creer un timer à une fréquence de 5 Hz (le timer 5)
# Créer un canal (channel) PWM avec le Timer.  
tim = pyb.Timer( 5, freq=100)
tchannel = tim.channel(1, Timer.PWM, pin=pyb.Pin.board.X1, pulse_width=0)

# Minimum et Maximum de largeur d'impulsion correspondant au minimum
# et maximum de luminosité
max_width = 150000
min_width = 8000

# fonction qui permet de passer d'un range de valeur (in_) à une autre
#    (out_) en appliquant une règle de trois. 
def arduino_map(x, in_min, in_max, out_min, out_max):
    return int( (x - in_min) * (out_max - out_min) // (in_max - in_min) + out_min ) 

while True:
	# Lectures analogiques
    ivalue = adc.read()
    
    # Transformer une valeur analogique (0 à 4096) en largeur d'impulsion (20000 à 2000000) 
    pulse_width = arduino_map( ivalue, 0, 4096, min_width, max_width )
    
    # Modifier le signal PWM
    tchannel.pulse_width( pulse_width )
    
    delay( 100 )

Cela ne fonctionne pas?

Il y a 3 choses à essayer.

Fonctionne sporadiquement

Cela est souvent dû à une connexion imparfaite des broches du potentiomètre.

Cela peut généralement être résolu en tapotant un peu sur le potentiomètre.

Cela ne fonctionne pas!

Assurez-vous de ne pas avoir accidentellement connecté le fil du potentiomètre sur la broche X9 au lieu de la broche X19 (la série de broche à l'opposé au port micro USB)

Toujours en panne?

Essayez de démonter et remonter le circuit, parfois cela fonctionne mieux.

Faire encore mieux

Page(s) en cours de traduction/élaboration. Page(s) under translation/construction

Seuil d'allumage (threshold)

Vous voulez parfois activer une sortie lorsqu'une valeur a atteint un certain seuil. Pour faire cela avec un potentiomètre, changez le code de loop() comme suit :

void loop() {
   int threshold = 512; // seuil = 512
   if(analogRead(sensorPin) > threshold){
      digitalWrite(ledPin, HIGH);
   }
   else{ 
      digitalWrite(ledPin, LOW);
   }
}

Cela allumera la LED lorsque la valeur sera supérieure à 512 (mi-course), vous pouvez adapter la sensibilité en modifiant la valeur du seuil (la variable threshold ).

Faire un Dimmer (fading)

Contrôlons maintenant la luminosité de la LED directement à partir du potentiomètre.

Pour y arriver, nous devons d'abord changer la broche sur laquelle la LED est connectée.

Déplacez le fil de la pin 13 à la pin 9 et changez la ligne de code:

int ledPin = 13;

vers

int ledPin = 9;

Modifiez ensuite le code de loop() comme suit :

void loop() {
   int value = analogRead(potPin) / 4;
   analogWrite(ledPin, value);
}

Chargez le code et regardez la luminosité de la LED varier en fonction de la position du potentiomètre. (Note: la raison pour laquelle nous avons divisé la valeur par 4 est que la fonction analogRead() retourne une valeur entre 0 et 1024 (10 bits), et que analogWrite() accepte une valeur entre 0 et 255 (8 bits).

Contrôler un servo

C'est vraiment un bel exemple qui regroupe ensemble une série de montages ensembles.

Raccordez le Servo moteur comme nous l'avons fait au CIRC-04, ouvrez le programme d'exemple nommé Knob (Fichier > Exemples > Servo > Knob ), changez ensuite une ligne de code.

int potpin = 0; 

vers

int potpin = 2;

Chargez sur votre Arduino et regardez l'axe du Servo tourner lorsque vous tournez le potentiomètre.

Parasites, lecture multiple et moyenne

Il est également possible de réaliser des lectures en rafale et de les stocker dans un tableau.

Cela permet d'effectuer une moyenne sur plusieurs lectures, une façon d'amortir l'implication d'une valeur parasite. Vous aurez en effet remarqué que la valeur varie sensiblement d'une lecture à l'autre même si vous ne bougez pas le potentiomètre.

Cela est provoqué par les différentes perturbations comme:

• Le bruit sur l'alimentation (surtout USB),
• Les connexion imparfaites (surtout sur les breadboard)
• La longueur des fils... qui sont sensibles au perturbation électromagnétique.
  blindez les et/ou utiliser une paire torsadée

La fonction ADC.read_timed(buffer, frequence) permet de faire de multiples captures sur une entrée et remplir un tableau. Il faut cependant faire attention au type de tableau passé en entrée... sinon vous passez en échantillonnage 8bits (avec des valeurs lue de 0 à 255).

Lecture en échantillonnage 8 Bits

Dans l'exemple suivant, issu de la doc officielle, les valeurs retournées varient entre 0 et 255. En effet, en passant un bytearray à la fonction read_timed() nous indiquons aussi que l'espace de stockage est un tableau de Byte (d'Octet)... et un Byte/Octet est stocké sur 8 bits. Par conséquent, le convertisseur anamogique/digital passe en résolution 8 bits!!!

# Lecture analogique avec moyenne.
# ATTENTION: échantillonnage 8 Bits (valeur de 0 à 255)

adc = pyb.ADC(pyb.Pin.board.X19)    # Créer ADC sur la broche  X19
buf = bytearray(100)                # Créer une mémoire tampon (buffer)
                                    #   de 100 octets/bytes
adc.read_timed(buf, 10)             # Lectures analogiques à la fréquence 
                                    #   de 10Hz, stockage directement dans
                                    #   le Buffer 
                                    #   Cela prendra 10 secondes pour
                                    #   être complètement achevé.

for val in buf:                     # Affichage de toutes les valeurs
    print(val)                     
    
# calcul de la moyenne
print( 'Moyenne: %s' % (sum(buf)/len(buf)) )

Lecture en échantillonnage 12 bits

Si vous avez été attentif au point précédent, vous savez maintenant qu'il faut faire attention à la création de la mémoire tampon (buffer) pour pouvoir réaliser des lectures multiples en 12bit.

Voici la marche à suivre pour garder un échantillonnage 12 bits (valeurs de 0 à 4095):

import pyb, array
# Utiliser une constante pour identifier la broche
adc = pyb.ADC( pyb.Pin.board.X19 )
# Créer et initialize un Buffer (mémoire tempon) capable de recevoir
# des valeurs 12bits. 
buf = array.array('H')
for i in range(10): buf.append( 0 )
# Passez votre curiosité dans la structure du tableau
#   print( buf )
# vous aurez une réponse comme celle-ci:
#   array('H', [0, 0, 0, 0, 0, 0, 0, 0, 0, 0])


# Faire une lecture de valeur analogique dans le buffer
# à une fréquence de 10 Hertz (cela prendra 10 secondes)
adc.read_timed(buf, 10) 
# Afficher les valeurs
for valeur in buf:
    print( valeur )
# calcul de la moyenne
print( 'Moyenne: %s' % (sum(buf)/len(buf)) )

Internet

Voici quelques ressources utiles.

• Améliorer la stabilité de la lecture analogique (Anglais, MicroPython Forum)

---

Composé par Meurisse D. pour MCHobby.be - Translated by Meurisse D. for MCHobby.be

Toute référence, mention ou extrait de cette traduction doit être explicitement accompagné du texte suivant : «  Traduction par MCHobby (www.MCHobby.be) - Vente de kit et composants » avec un lien vers la source (donc cette page) et ce quelque soit le média utilisé.

L'utilisation commercial de la traduction (texte) et/ou réalisation, même partielle, pourrait être soumis à redevance. Dans tous les cas de figures, vous devez également obtenir l'accord du(des) détenteur initial des droits. Celui de MC Hobby s'arrêtant au travail de traduction proprement dit.