Le capteur MPX5700AP
Le matériel
Présentation du matériel
Généralement livré avec la seringue et le tube en plastique. On distingue bien une suele entrée sur le capteur (pression absolue (par rapport aux modèles à deux entrées (pression relative)
Caractéristiques:
Interface: analogique compatible Grove
Alimentation: 3,3 à 5 Vcc
Plage de mesure: 0 à 700 kPa
Sensibilité: 6,4 mV/kPa
Dimensions: 49 x 31 x 15 mm
Référence Seeedstudio: 110020248
A moins de 40 euros l'ensemble, c'est intéressant, le capteur seul est à 20 euros, et la partie électronique nécessaire pour le faire fonctionner n'est pas évidente à mettre en œuvre.
Par contre, cela nécessite une carte Grove pour plus de confort, à noter que si on ne dispose pas de carte, on peut brancher des fils directement entre la carte Arduino et l'interface GROVE, du capteur.
Mise en œuvre
Le montage
Pas compliqué, noter juste l'entrée utilisée sur la carte Grove , il s'agit du port A0, tout autre port analogique sera également fonctionnel (A1, A2 ou A3).
En étudiant le diagramme, on constate qui ne va pas forcément passer par l'origine, il faudra éventuellement calibrer . LA pente vaut 4.6/700 = 0.571 V.kPa-1.
Pour commencer, pas de librairie à importer, ce code teste plusieurs architectures possible (plusieurs cartes possibles).
On pourrait se passer des 20 premières lignes, le code simplifié pour Arduino Uno uniquement donnerait :
int rawValue; // A/D readings
int offset = 410; // zero pressure adjust
int fullScale = 9630; // max pressure (span) adjust
float pressure; // final pressure
void setup() {
Serial.begin(9600);
}
void loop() {
rawValue = 0;
for (int x = 0; x < 10; x++) rawValue = rawValue + analogRead(A0);
pressure = (rawValue - offset) * 700.0 / (fullScale - offset); // pressure conversion
Serial.print("Raw A/D is ");
Serial.print(rawValue);
Serial.print(" Pressure is ");
Serial.print(pressure, 1); // one decimal places
Serial.println(" kPa");
delay(1000);
}
// MPX5700 pressure sensor (700kPa)int rawValue; // A/D readings
int offset = 410; // zero pressure adjust
int fullScale = 9630; // max pressure (span) adjust
float pressure; // final pressure
void setup() {
SERIAL.begin(9600);
}
void loop() {
rawValue = 0;
for (int x = 0; x < 10; x++) rawValue = rawValue + analogRead(A0);
pressure = (rawValue - offset) * 700.0 / (fullScale - offset); // pressure conversion
SERIAL.print("Raw A/D is ");
SERIAL.print(rawValue);
SERIAL.print(" Pressure is ");
SERIAL.print(pressure, 1); // one decimal places
SERIAL.println(" kPa");
delay(1000);
}
Aller plus loin avec python
Récupérer et traiter les mesures
Lire information dans la console, c'est un peu limité, surtout pour travailler avec des élèves.
Même si le copier / coller dans libreoffice calc fonctionne assez bien.
Première méthode (réutilisable pour d'autres occasions similaires) récupérer les données en csv
Récupérer les données en csv
Sur le principe, cela n'est pas compliqué :
On programme l'Arduino pour envoyer les données sur le port série à intervalles réguliers .En fait, on ne change rien au code sur le fond, si ce n'est de proposer une mise en forme différente.
Sur cet exemple, on affiche la pression calculée à la demande
On programme ensuite en python la lecture à la demande sur le port usb(port série)
Pour la partie arduino, le code est ci-dessous,
lignes 23 à 30, on a isolé la mesure dans une fonction qui ne retourne que la pression .
boucle principale :
La variable inString contient l'instruction envoyée par le script python.
Pour l'instant on fait simple, si la données reçue est le caractère m, on fait une mesure, on l'écrit sur le port série, puis on rend la main (en faisant un retour à la ligne Serial.println)
Sinon, on renvoie None
La fonction serialEvent permet de stocker les données envoyées par le script python, quand le caractère fin de ligne est détecté ('\n') , alors l'ensemble des données est stockée dans la variable InString, et le booléen String Complete passe à Vrai
//Definition de varibles et constantes //nécessaires aux mesuresint rawValue; // A/D readings
int offset = 410; // zero pressure adjust
int fullScale = 9630; // max pressure (span) adjust
float pressure; // final pressure
//on déclare une variable chaine de caractères//qui stockera notre commandeString inString="";
//Vrai/Faux, pour tester si la commande est envoyée//en faite on repérera la commande fin de ligne '\n'boolean stringcomplete=false;
void setup()
{ //ouverture du port série à 9600 baudsSerial.begin(9600);
//reseve 128 byte en mémoire pour stocker un string inString.reserve(128);
}
float mesurepression(){
rawValue = 0;
//pour 10 mesuresfor (int x = 0; x < 10; x++) rawValue = rawValue + analogRead(A0);
//calcul de la pression en tenant compte de l'électroniquepressure = (rawValue - offset) * 700.0 / (fullScale - offset); // pressure conversion
return pressure;
}
void loop()
{if(stringcomplete){
if(inString == "m") {
Serial.println(mesurepression(),1);
}
else Serial.println("none");
inString="";
stringcomplete=false;
}
}
void serialEvent (){
while (Serial.available()) { // tant que des caractères sont en attente d'être lus
char c = (char) Serial.read(); // on lit le charactère
//Serial.print(c); //detecté si nouvelle ligne est cochéif(c == '\n'){
//Serial.print(inString);stringcomplete = true;
} else {inString +=c;
//Serial.print(inString);}
}
}
Le script python peut ainsi piloter la carte et nregistrer les données au format csv pour le traiter dans un tableur .
import serial, time
ser = serial.Serial('/dev/ttyACM0', 9600)
commande=''
mesures = 'mesures.txt'
f =open(mesures,'w')
while commande != 'toto' :
commande= input('V: en mL')
#print(commande) #ser.write((commande).encode('utf8'))ser.write(b'm\n')
serial_line = ser.readline()
print(serial_line.decode('utf8'))
if commande != 'toto' :
f.write(serial_line.decode('utf8').strip().replace(".",",") + ";" + commande + '\n')
#time.sleep(1) # sleep 5 minutes # Loop restarts once the sleep is finishedf.close()
ser.close() # Only executes once the loop exitsblur
La preuve en image !