ACTIVITE ARDUINO : Mesure de forces avec le banc de traction NOVA PHYSICS

Présentation du banc de traction

Le banc de traction NOVA PHYSICS est un système pilotable de translation par moteur pas à pas 200 pas sur une platine de translation (course 120mm, vitesse lente de  0 à 10 mm/s). Le couple élevé du moteur permet de réaliser des tests de traction, de compression et d’élasticité.

Le guidage se fait par vis à bille et roulements linéaires. Ce banc se pilote avec le logiciel NOVAControl (par l’intermédiaire d’un boîter de contrôle) , avec lequel il est possible de modifier différents paramètres (déplacement, vitesse , sens …). Ce logiciel permet aussi de régler les paramètres d’acquisition pour les capteurs qu’on branche sur les entrées analogiques A0 et A1 du boîtier de contrôle.

Réalisation du capteur de force pour ce système

Dans cet article, nous allons nous attarder sur la réalisation et l’étude d’un capteur de force qu’il sera possible de brancher sur le boîter de contrôle.

Nous allons utiliser le même capteur de force que celui étudié dans cet article.

Le capteur de force est constitué de :

Voici le montage à réaliser :

Une petite explication s’impose pour ce montage !

Nous voulons récupérer grâce à un code Arduino une « tension-image » de la force mesurée, grâce à la broche PWM 9 de la carte Arduino avec la ligne de commande :

   analogWrite(pinPWM, sortiePWM);

Mais nous n’allons pas pouvoir récupérer une « vraie » tension analogique à la sortie de cette broche 9.

En effet, les sorties Arduino ne peuvent délivrer qu’une tension de 0 V (état LOW) ou de 5V (état HIGH). Avec les sorties PWM (Pulse Width Modulation, en français MLI ou Modulation de Largeur d’Impulsions ), il est possible de « hacher » cette tension de 5 V en faisant varier le rapport cyclique du signal donné par la broche (le rapport cyclique est le rapport de la durée du signal au niveau haut divisé par le temps de la période du signal).

Avec l’instruction analogWrite (uniquement valable pour les sorties PWM) , nous pouvons jouer sur le rapport cyclique, avec une valeur comprise entre 0 (0%) et 255 (100%).

La valeur moyenne de cette tension sera donc égale à :

U_moyenne = rapport cyclique x 5V

Cette tension est mesurable avec un voltmètre , mais le boîtier de contrôle NOVA (qui est aussi un système Arduino) ne pourra mesurer uniquement des valeurs de 5V ou 0 V. Il est donc nécessaire d’ajouter un petit filtre RC (filtre passe-bas résistance + condensateur) pour transformer la PWM en vraie tension lissée.

Donc pour résumer :

• La carte Arduino utilisée pour le capteur de force lit la masse avec le HX711.
• Cette valeur (–5000 g à 0 g dans notre cas) est convertie en un signal PWM (0 à 255).
• Un filtre RC transforme cette PWM en tension lissée.
• Cette tension sera envoyée vers A0 du boîter de contrôle NOVA.
• Le logiciel Nova Control pourra lire cette tension 1V<-> 1000 g <-> 10N environ .

Voici le code Arduino :

// En sortie filtre passe bas R = 47 kOhms, C = 10 microF

#include "HX711.h"

HX711 capteur;
int DAT = 3;
int CLK = 2;

long valeur;
float valeur2;

int pinPWM = 9;  // Pin PWM vers filtre RC puis A0 de l’autre Arduino

void setup() {
  capteur.begin(DAT, CLK);
  Serial.begin(9600);
  capteur.tare();
  delay(1000);
}

void loop() {
  valeur = capteur.get_value();
  valeur2 = 0.00234 * valeur - 0.328;   // ta conversion en grammes

  // Conversion -5000…5000 g -> PWM 0…255
  int sortiePWM = map(valeur2, -5000, 0, 255, 0);
  sortiePWM = constrain(sortiePWM, 0, 255);

  analogWrite(pinPWM, sortiePWM); // PWM vers filtre RC

  // debug
  Serial.println(valeur2);
    Serial.println(sortiePWM);

  

  delay(20);
}

Remarque

On pourrait étalonner ce capteur en réalisant des mesures avec une gamme de masses étalon.

A l’issue de ces résultats, il faudrait alors modifier la formule donnant la masse « réelle » :

valeur2 = 0.00234*valeur -0.328

Autre remarque

La carte peut contrôler le rapport du cycle PWM avec une sensibilité de 8 bits : la commande dans l’instruction analogWrite est donc un chiffre entier compris entre 0 et 255 (2⁸ =256 valeurs).

Il n’est donc possible de récupérer que 256 valeurs entre 0 et 5 V. Pour un capteur de de force 0 kg – 5 kg, le pas de résolution sera donc de :

5000 / 256 = 19,5 g environ

Ce qui représente une valeur assez élevée ! Il serait donc nécessaire d’adapter la gamme du capteur de force à l’expérience, et modifier le code Arduino en conséquence afin d’avoir la meilleure sensibilité possible.

Tout ce montage a été encapsulé dans un boîtier « maison » pour simplifier l’utilisation dans le cadre d’expériences, en séances de travaux pratiques ou de TIPE :

Mesures avec le banc de traction Nova (exemple d’utilisation avec mesure de constante de raideur d’un ressort)

Boîtier de contrôle NOVA

• Brancher le boîtier de contrôle NOVA au secteur à l’aide un bloc d’alimentation 12 V (la prise sur le boîtier est celle du haut).
• Connecter à l’aide d’un câble jack les détecteurs de fin de course, ce qui permet d’arrêter le moteur en toute sécurité quand le chariot arrive aux extrémités de la vis à bille.
• Connecter le boîtier à un ordinateur avec un câble USB.

Capteur de force

• Connecter la sortie (pseudo !) analogique du capteur de force au boîtier de contrôle NOVA.

Acquisition avec le logiciel NovaControl

• Avant d’accrocher le ressort, éteindre puis allumer le capteur de force pour faire le zéro
• Puis accrocher le ressort au banc et au capteur de force
• Lancer le logiciel Nova Control et faire les réglages suivants :

• Positionner le chariot à droite en cliquant sur OUT
• Puis relancer l’acquisition en cliquant sur IN pour tendre le ressort.

Export et traitement de données

Cliquer en haut sur Export de la sélection, Export complet et enregistrer le fichier txt

Avec Regressi

• Fichier/Ouvrir , sélectionner type de fichier txt, puis ouvrir le fichier.

• Dans l’onglet Expressions (feuille de calcul), convertir les positions en m et la tension mesurée correspondant à la force en N, puis cliquer sur Mise à jour :

• Afficher dans Graphe /Coord., la force en fonction de x

• Puis dans Modélisation, ajuster avec le modèle affine pour retrouver la constante de raideur du ressort (ici de 40 N/m)

Avec Latis Pro

• Fichier/Importation , ouvrir le fichier txt puis faire glisser Position en abscisse et Signal1 en ordonnée.

• Dans l’onglet Feuille de calculs (F3), convertir les positions en m et la tension mesurée correspondant à la force en N, puis valider avec F2 :

• Dans Liste des courbes, faire glisser Force en ordonnée et x en abscisse :

• Puis dans Traitements/Modélisation, ajuster avec le modèle affine pour retrouver la constante de raideur du ressort (ici de 40 N/m)

Avec Python

Lancer ce script Python pour importer les données et faire une régression linéaire :

# -*- coding: utf-8 -*-
"""
Tracé de la force en fonction de la position pour un ressort sur le banc de traction, et  régression linéaire avec la fonction stats.linregress de scipy
"""

#########################################  IMPORTATION DES BIBLIOTHEQUES ET MODULES  ########################################################

import numpy as np  # numpy pour les maths , par exemple pour créer 256 valeurs régulièrement espacées entre 0 et 10 : np.linspace(0,10,256)
import matplotlib.pyplot as plt # pour les tracés de graphique
from scipy import stats # module permettant de faire la régression linéaire à partir d'une liste X et d'une liste Y, stats.linregress(X,Y) renvoie 5 valeurs. Les 3 premières valeurs sont la pente, l'ordonnée à l'origine, et le coefficient de corrélation (à mettre au carré)

# importation des donnees txt obtenues avec le logiciel NovaControl
lines = open('donnees_banc_traction.txt').readlines() # ouverture du fichier texte
for i in range(len(lines)):                  # On remplace les virgules par des points pour les nombres décimaux
   lines[i]=lines[i].replace(',','.')

open('data.txt', 'w').writelines(lines[1:]) #création d'un nouveau fichier texte sans la première ligne
data = np.loadtxt('data.txt')# importation du nouveau fichier texte pour récupérer les valeurs det, x et y dans un tableau

x = data[:,1]*0.001 # selection de la deuxième colonne et conversion de la position en m
y = data[:,2]*9.81  # selection de la troisième colonne, force en N à partir de la tension mesurée



#################################   REGRESSION LINEAIRE ET TRACE DE GRAPHIQUE ########################################################################################

eq = stats.linregress (x,y) # pour faire la régression linéaire

pente = eq[0] # pente
ordorig = eq[1] # ordonnée à l'origine
coeff2 = eq[2]**2 # coefficient de corrélation au carré r²

Xcalc = np.linspace(0,max(x) , 256) # création de points pour le tracé du modèle : on crée 256 points régulièrement espacés entre 0 et la valeur max de I
Ycalc = pente*Xcalc+ordorig # on fait calculer U avec les paramètres de la régression linéaire pour ces valeurs de I
texte = 'equation de la droite  F = '+str(round(pente,3))+' x + '+str(round(ordorig,3))+'     R² = '+str(round(coeff2,3)) # on affiche l'équation de la droite avec 3 décimales

print (texte)
plt.title('F=f(x)') # titre du graphique
plt.scatter(x,y, color ='r', marker = 'o') # On affiche les points de coordonnées (x, forceU) avec des points rouges
plt.plot(Xcalc,Ycalc,color = 'b',label = texte) # Affichage de la courbe modélisée en bleu
plt.xlabel('x en m')       # nommer l'axe des abscisses
plt.ylabel('F en N')       # nommer l'axe des ordonnéees
plt.legend()   # pour afficher les légendes (label)
plt.show()  #afficher le graphique (ne rien mettre dans la parenthèse)