Récupération des données d'arduino vers labview

International Français
1

Bonjour, je dois finaliser un projet sur le quel je dois récupérer les signaux analogiques d’un banc de testes : la tension(pzt), la vitesse (moteur à courant continue) et le poids appliqué sur l’échantillon.

Le banc de teste est piloté par un programme Arduino et la récupération des signaux (courbes) doit se faire sur LabVIEW.

A noter :

Le programme Arduino doit assurer plusieurs taches mais les plus importantes sont :

Mesure de la force appliquée sur le capteur de charge

Mesurer la tension analogique d’un pzt

Mesurer la vitesse du moteur

Et tout cela aura pour but de transmettre toutes ces données à un port série vers LabVIEW.

Dans un premier temps, pour téléverser le programme ; j’ai effectué une lecture du port série à travers le sérial Visa pour la suite vidé le port série sur LabVIEW. Cependant, ça n’a pas marché j’ai des valeurs nulles sur mes courbes.

Je voulais utiliser LIFA (LabVIEW, Interface For Arduino) base mais pour l’instant je ne comprends pas comment ça marche c’est-à-dire que je ne sais pas si je peux récupérer les données directement sur les pins de la carte Arduino qui contiennent les informations dont j’ai besoin avec LIFA.

Je suis donc à la recherche d'aide pour résoudre ce problème. Toute suggestion serait grandement appréciée. Merci d'avance pour votre aide.

2

Avez vous déjà ce programme fonctionnel ?

3

Oui le programme est fonctionnel. Il me reste à récupérer les données sur labVIEW.

4

je n'ai pas labView (trop cher quand on n'est pas à l'école ni un besoin pro) mais il me semble q'il suffit de faire des println() des valeurs que l'on veut exporter et de créer le programme labVIEW qui attend ces données pour les exploiter;

5

bonsoir,

dans ce cas, fournis-le (entre balises, comme demandé dans Les bonnes pratiques du Forum Francophone), on verra ensuite s'il faut ou pas améliorer quelquechose.

ce n'est pas le plus difficile, si les données envoyées par ta carte sont "propres" et que tu gères efficacement les transferts.

1ère étape : format des données
j'ai pour habitude de ne jamais "bricoler" les données issues d'un capteur, c-à-d que j'essaie toujours de conserver les données "brutes" qu'il me fournit.
j'évite donc les Serial.print() qui formattent les données numériques sous forme de texte, que tu devras de toute façon retravailler par la suite pour pouvoir les exploiter (dans LabView, par exemple, il faudra passer par des outils type StringToNum qui ne feront que refaire le boulot inverse : totalement inutile, sans compter les éventuelles pertes lors de la première conversion).

2ème point : début/fin des trames
pour envoyer des données brutes il te faut créer un protocole de communication qui va te permettre de les transmettre avec la certitude qu'elles seront correctement reçues, tu dois donc prévoir des messages comportant un en-tête qui permettra à ton récepteur de déterminer le début de trame, et donc de gérer la réception en détectant tes données à leurs bonnes place et taille dans le flux transmis.
(à noter que même avec Serial.print() tu seras obligé de filtrer...)
et le mieux est d'ajouter aussi une fin de trame !

3ème phase : quel port COM:?
je ne sais pas si tu l'as déjà remarqué : la même carte (Arduino ou autre) ne va pas forcément se voir attribuer le même numéro de port COM: suivant qu'elle est connectée au même port USB ou pas, ou si entre deux tu as branché une autre carte...
il va te falloir gérer ça aussi, sinon c'est une galère ... comme dans l'IDE Arduino où tu dois choisir le bon port COM à chaque fois que tu changes de carte !
ce n'est pas super compliqué : je pourrai te donner des astuces si tu ne les trouves pas ailleurs, mais en gros, si tu gères le flux des erreurs tu peux éviter les plantages de ton VI ... c'est une 1ère piste.

commence par fournir tes softs : ton code C/C++ et ton VI

(pour le VI : convertis-le en version 2017 ou antérieure si tu peux, sinon fais-en une image ou un PDF)

6

Bonjour, je vous remercie pour le temps que vous me me consacriez. Vous verrez le code en balise et une description du VI en PDF.


```cpp
#include <LiquidCrystal.h>
#include <Arduino.h>
#include <RotaryEncoder.h>
#include <Wire.h>


#define DT A0
#define SCK A1
#define sw 13
#define PIN_LED_ROUGE 3
#define DEMI_PERIODE_ROUGE 150
#define PIN_LED_VERTE 6  // Led connectéé patte 6 protection capos
#define DEMI_PERIODE_VERTE 260
#define basculeLED(x) digitalWrite(x, !digitalRead(x))

//////////////////// Programme Commande du moteur CC

// création des variables pour les broches
const int buttonPROTECT = 40;
const int Broche_Marche_Arret = 46;
const int Broche_Moteur = 9;
const int Broche_POT = A2;
const int swPin = 53;  ///encodeurbp
int POT_Valeur;        // permet de relever la valeur du potentiometre

float Tension;  // pour convertir la vaaleur du POT en Tensio
float a;        // le coef directeur
float Vitesse_MCC;

////////////////recuperation piezo
word Val_piezo = 0;
float Tension_piezo;  //pour convertir la valeur de A5 en Tension
////////////////constant balance
long sample = 0;
float val = 0;
long count = 0;
//////////////////////////////programation millis
long prevMillis = 0;


bool State_bottom = LOW;
////////////////////////////////////////////////////////////////////////
int buttonstate = 0;  // déclaration de la broche du bouton protection

///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////


int Sortie_PWM;  // gerer la sortie du PWM

float Pourcentage_Sortie_PWM;  // convertir en pourcentage
float b;                       // coef directeur

int BP_Etat = 0;
int BP_Etat_Pre = 0;

int Moteur = 0;
int valeur = 0;
int i;
LiquidCrystal_I2C LCD(0x26, 20, 4);  // definir les caracteristique de l'ecran LCD

#define PIN_IN1 52
#define PIN_IN2 50
bool swState = HIGH;
bool swLast = HIGH;

#if defined(ARDUINO_AVR_UNO) || defined(ARDUINO_AVR_NANO_EVERY)
// Example for Arduino UNO with input signals on pin 2 and 3



#elif defined(ESP8266)
// Example for ESP8266 NodeMCU with input signals on pin D5 and D6
#define PIN_IN1 4
#define PIN_IN2 3
#endif

#define ROTARYSTEPS 30
#define ROTARYMIN 160
#define ROTARYMAX 1000

// Setup a RotaryEncoder with 4 steps per latch for the 2 signal input pins:
//RotaryEncoder encoder(PIN_IN1, PIN_IN2, RotaryEncoder::LatchMode::FOUR3);

// Setup a RotaryEncoder with 2 steps per latch for the 2 signal input pins:
RotaryEncoder encoder(PIN_IN1, PIN_IN2, RotaryEncoder::LatchMode::TWO03);

// Last known rotary position.
int lastPos = -1;

////// comptage
unsigned long readCount(void) {
  unsigned long Count;
  unsigned char i;
  pinMode(DT, OUTPUT);
  digitalWrite(DT, HIGH);
  digitalWrite(SCK, LOW);
  Count = 0;
  pinMode(DT, INPUT);
  while (digitalRead(DT))
    ;
  for (i = 0; i < 24; i++) {
    digitalWrite(SCK, HIGH);
    Count = Count << 1;
    digitalWrite(SCK, LOW);
    if (digitalRead(DT))
      Count++;
  }
  digitalWrite(SCK, HIGH);
  Count = Count ^ 0x800000;
  digitalWrite(SCK, LOW);
  return (Count);
}


void setup() {

  Serial.begin(9600);
  while (!Serial)
    ;
  pinMode(buttonPROTECT, INPUT_PULLUP);
  pinMode(PIN_LED_ROUGE, OUTPUT);  // onfiguration des sortie des lED
  pinMode(PIN_LED_VERTE, OUTPUT);  //configuration des sortie des lED
  pinMode(SCK, OUTPUT);
  pinMode(sw, INPUT_PULLUP);
  LCD.backlight();
  LCD.init();  // initialize the lcd
  //LCD.begin(0, 0);
  LCD.setCursor(5, 0);
  LCD.print(" PIEZO ");
  LCD.setCursor(3, 1);
  LCD.print(" APPLICATION ");
  LCD.setCursor(4, 2);
  LCD.print(" EQUIPE 405 ");
  LCD.setCursor(13, 3);
  LCD.print(" by NTA ");
  delay(8000);
  LCD.clear();
  calibrate();



  //Init Serial USB
  pinMode(swPin, INPUT_PULLUP);
  Serial.begin(115200);
  while (!Serial)
    ;
  Serial.println("LimitedRotator example for the RotaryEncoder library.");
  encoder.setPosition(10 / ROTARYSTEPS);  // start with the value of 10.
}  // setup()


// Read the current position of the encoder and print out when changed.
void loop() {
  ///////////////////////////////////////CALIBR
  buttonstate = digitalRead(buttonPROTECT);
  count = readCount();
  int P = (((count - sample) / val) - 2 * ((count - sample) / val));
  LCD.setCursor(0, 0);  // place le curseur au 1er caractère de la 2nde ligne
  LCD.print("Poids APPL :  ");
  LCD.setCursor(13, 0);
  LCD.print(P * (-1));
  LCD.print("g ");

  // affiche le message de l'encoduer sur LCD
  LCD.setCursor(0, 1);
  LCD.print("Consigne :");

  LCD.setCursor(10, 1);
  LCD.print(valeur);
  LCD.print("tr/min ");

  LCD.setCursor(0, 2);
  LCD.print("Choix : ");


  if (digitalRead(sw) == 0) {
    val = 0;
    sample = 0;
    P = 0;
    count = 0;
    calibrate();
  }
  //delay(5);// le temps pour l'encodeur avant de faire une boucle
  if (millis() - prevMillis > 5) {
    prevMillis = millis();
    encoder.tick();
  }

  // get the current physical position and calc the logical position
  int newPos = encoder.getPosition() * ROTARYSTEPS;

  if (newPos < ROTARYMIN) {
    encoder.setPosition(ROTARYMIN / ROTARYSTEPS);
    newPos = ROTARYMIN;

  } else if (newPos > ROTARYMAX) {
    encoder.setPosition(ROTARYMAX / ROTARYSTEPS);
    newPos = ROTARYMAX;
  }  // if

  if (lastPos != newPos) {
    LCD.setCursor(8, 2);
    LCD.println(" ");
    Serial.print(" ");
    LCD.setCursor(8, 2);
    LCD.print(newPos);

    Serial.println(" | Choix : ");
    Serial.println(newPos);
    lastPos = newPos;
  }  // if

  swState = digitalRead(swPin);
  if (swState == LOW && swLast == HIGH) {
    valeur = newPos;
    LCD.setCursor(13, 1);
    LCD.print(" ");
    Serial.print(" ");
    Serial.println("Rotary pressed");
    //delay(100);//debounce
    //le temps pour l'encodeur avant de faire une boucle

    if (millis() - prevMillis > 10) {
      prevMillis = millis();
    }
  }

  ////////////////////////////////////////////////////////////moteur
  BP_Etat = digitalRead(Broche_Marche_Arret);  // permet d'allumer ou eteindre le moteur
  Serial.print("Etat BP ");
  Serial.print(BP_Etat);

  //digitalWrite (Broche_Moteur, HIGH);
  POT_Valeur = analogRead(Broche_POT);  //permet de relever la valeur du potentiometre
  Serial.print(" | Valeur POT: ");
  Serial.print(POT_Valeur);

  Vitesse_De_Rotation();


  // ALgorithme télérupteur
  buttonstate = digitalRead(buttonPROTECT);
  if (buttonstate == HIGH) {
    if ((BP_Etat == HIGH) && (BP_Etat_Pre == LOW))  // permet au bouton poussoir de fonctionner sur front
    {
      Moteur = 1 - Moteur;
    }

    BP_Etat_Pre = BP_Etat;

    if (Moteur == 1) {
      analogWrite(Broche_Moteur, Sortie_PWM);
      LCD.setCursor(0, 3);
      LCD.print(" Moteur  RUN ");
      Serial.println("  | Moteur MARCHE ");
    }

    else {
      digitalWrite(Broche_Moteur, LOW);
      LCD.setCursor(0, 3);
      LCD.print(" Moteur STOP ");
      Serial.println("  | Moteur ARRET ");
    }
  }

  else

  {
    digitalWrite(Broche_Moteur, LOW);
    LCD.setCursor(0, 3);
    LCD.print(" close capot ");
    ///////////////////////////////////////LED1
    static unsigned long dernierRouge = 0, dernierverte = 0;

    if ((millis() - dernierverte) >= DEMI_PERIODE_VERTE) {
      dernierverte = dernierverte + DEMI_PERIODE_VERTE;
      basculeLED(PIN_LED_VERTE);
    }
    ///////////////////////////////////////
  }


}  // loop ()


void calibrate() {

  static unsigned long dernierRouge = 0;
  if ((millis() - dernierRouge) >= DEMI_PERIODE_ROUGE) {
    dernierRouge = dernierRouge + DEMI_PERIODE_ROUGE;
    basculeLED(PIN_LED_ROUGE);
  }
  LCD.backlight();  // active le rétro-éclairage
  LCD.clear();
  LCD.setCursor(3, 1);
  LCD.print("Calibrage...");
  LCD.setCursor(5, 2);
  LCD.print("Please Wait...");

  for (int i = 0; i < 100; i++) {
    count = readCount();
    sample += count;
  }
  sample /= 100;

  LCD.clear();
  LCD.setCursor(1, 1);
  LCD.print("pressez la cellule");
  LCD.setCursor(8, 2);
  LCD.print(" de");
  LCD.setCursor(7, 3);
  LCD.print("charge");
  count = 0;
  while (count < 1000)  //
  {

    count = readCount();
    count = sample - count;
  }
  LCD.clear();
  LCD.setCursor(4, 2);
  LCD.print("Please Wait....");
  delay(2000);
  for (int i = 0; i < 100; i++) {
    count = readCount();
    val += sample - count;
  }
  val = val / 100.0;
  val = val / 100.0;  // effectuer la premiere fapper a 20tr/min
  LCD.clear();
}


void Vitesse_De_Rotation() {
  a = 5.0 / 1023.0;      // le calcul du coef directeur
  Tension = a * valeur;  // pour convertir la vaaleur du POT en Tension
  Serial.print(" | Tension: ");
  Serial.print(Tension);

  Sortie_PWM = valeur / 4;  // gerer la sortie du PWM, 1023/4= 255.75 alors l'entree ANA est de 0 à 1023 et la sortie PWM varie de 0 à 255
  Serial.print(" | Sortie PWM: ");
  Serial.print(Sortie_PWM);


  b = 100.0 / 255.0;  // calcul du coef directeur equation 0-100% 0-255
  Pourcentage_Sortie_PWM = b * Sortie_PWM;
  // Serial.print(" |Pourcentage_Sortie_PWM:  ");
  // Serial.print(Pourcentage_Sortie_PWM);

  Vitesse_MCC = 1000 * Tension;  // gerer la sortie du PWM, 1023/4= 255.75 alors l'entree ANA est de 0 à 1023 et la sortie PWM varie de 0 à 255
  Serial.print(" | Vitesse MCC : ");
  Serial.print(Vitesse_MCC);
}
7

Malheureusement, j'ai pas pu vous transmettre la fiche pdf :sleepy:. Apparemment, les nouveaux utilisateurs n'ont pas le droit.

8

bonsoir, @dounexaf

j'ai jeté un rapide coup d'oeil à ton code-source :

tu utilises Serial.println(); pour l'envoi des données via le port série, précédé à chaque fois d'un message constant ("valeur truc", "tension machin", etc).
ce message constant peut te servir d'en-tête pour discriminer à la réception le type de la donnée reçue, et le code de contrôle retour-ligne/retour-chariot peut servir de fin de trame : sers-t'en dans LabVIEW.

dans un premier temps, avant de passer à l'écriture du VI dans LabVIEW, utilise le Moniteur Série de l'IDE Arduino pour vérifier que ton programme fonctionne comme tu le souhaites : si le Moniteur Série t'affiche ce que tu souhaites transmettre c'est gagné.
tu pourras ainsi commencer à débugger si nécessaire : tant que cette partie ne sera pas validée il est inutile de te consacrer à la conception d'un module qui en dépend totalement.

au plaisir de te lire.

je ne me souviens plus au bout de combien de temps (ou de messages ?) il est autorisé d'inclure une image ou un fichier ...

9

Merci pour vos aides. Vous avez raisons. J'ai essayer de voir les valeurs avec le moniteur série mais ça affiche les ligne des caractère (%^¨). Ce pendant j'ai compris mieux le principe et comme vous me l'avez conseillé, je vais utiliser d'abord le moniteur Série de l'IDE Arduino pour vérifier que le programme fonctionne d'abord. Etant donné que je suis nouveau sur Arduino, je pense que le mieux c'est de faire de petit programme pouvoir un en un les signaux analogiques que souhaite avant de faire un gros programme.

10

Avez vous un moins qui me permettra d'avoir les données brutes des capteurs sans faire retour au serial.print() à me suggérer.

11

bonsoir, @dounexaf

dans un premier temps, vérifie que les réglages de vitesse de transmission sont les mêmes à la fois dans le moniteur et dans ton programme.

je vois dans ton Setup() :

cette valeur doit être la même dans le réglage (en bas, à droite) du moniteur série.

quand les deux seront synchronisés ils pourront alors dialoguer ;
je pense que tu obtiendras alors des messages lisibles.

le même problème se posera dans LabVIEW : les réglages pour la communication se font à l'identique.

12

Bonsoir 5_cylindres,
Je vous remercie sur les conseils que vous m'aviez donnés. Actuellement j'ai pu récupérer sur le moniteur la tension du piézoélectrique et la vitesse de la machine continue. Il me reste qu'a récupérer la masse appliquée.

J'ai essayer de voir la communication entre arduino et LabVIEW. Cependant, y'a que la vitesse de la machine que je visualise alors que sur le moniteur j'avais la tension piezo du pin 5.

Espérant que ce message vous trouvera en bonne santé,

merci d'avance pour votre aide.

Vous pouvez voir en pièce jointe le VI et le code arduino.

VI_ZIP.zip (72,8 Ko)


#include <Arduino.h>
#include <RotaryEncoder.h>
#include <Wire.h>
#include <LiquidCrystal_I2C.h>
#define DT A0
#define SCK A1
#define sw 13
#define PIN_LED_ROUGE 3
#define DEMI_PERIODE_ROUGE 150
#define PIN_LED_VERTE 6  // Led connectéé patte 6 protection capos
#define DEMI_PERIODE_VERTE 260
#define basculeLED(x) digitalWrite(x, !digitalRead(x))

//////////////////// Programme Commande du moteur CC

// création des variables pour les broches
const int buttonPROTECT = 40;
const int Broche_Marche_Arret = 46;
const int Broche_Moteur = 9;
const int Broche_POT = A2;
const int swPin = 53;  ///encodeurbp
int POT_Valeur;        // permet de relever la valeur du potentiometre

float Tension;  // pour convertir la vaaleur du POT en Tensio
float a;        // le coef directeur
float Vitesse_MCC;

////////////////recuperation piezo
word Val_piezo = 0;
float Tension_piezo;  //pour convertir la valeur de A5 en Tension
////////////////constant balance
long sample = 0;
float val = 0;
long count = 0;
//////////////////////////////programation millis
long prevMillis = 0;


bool State_bottom = LOW;
////////////////////////////////////////////////////////////////////////
int buttonstate = 0;  // déclaration de la broche du bouton protection

///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////


int Sortie_PWM;  // gerer la sortie du PWM

float Pourcentage_Sortie_PWM;  // convertir en pourcentage
float b;                       // coef directeur

int BP_Etat = 0;
int BP_Etat_Pre = 0;
int Moteur = 0;
int valeur = 0;
int i;
LiquidCrystal_I2C LCD(0x26, 20, 4);  // definir les caracteristique de l'ecran LCD



#define PIN_IN1 52
#define PIN_IN2 50
bool swState = HIGH;
bool swLast = HIGH;

#if defined(ARDUINO_AVR_UNO) || defined(ARDUINO_AVR_NANO_EVERY)
// Example for Arduino UNO with input signals on pin 2 and 3



#elif defined(ESP8266)
// Example for ESP8266 NodeMCU with input signals on pin D5 and D6
#define PIN_IN1 4
#define PIN_IN2 3
#endif

#define ROTARYSTEPS 30
#define ROTARYMIN 160
#define ROTARYMAX 1000

// Setup a RotaryEncoder with 4 steps per latch for the 2 signal input pins:
//RotaryEncoder encoder(PIN_IN1, PIN_IN2, RotaryEncoder::LatchMode::FOUR3);

// Setup a RotaryEncoder with 2 steps per latch for the 2 signal input pins:
RotaryEncoder encoder(PIN_IN1, PIN_IN2, RotaryEncoder::LatchMode::TWO03);

// Last known rotary position.
int lastPos = -1;

////// comptage
unsigned long readCount(void) {
  unsigned long Count;
  unsigned char i;
  pinMode(DT, OUTPUT);
  digitalWrite(DT, HIGH);
  digitalWrite(SCK, LOW);
  Count = 0;
  pinMode(DT, INPUT);
  while (digitalRead(DT))
    ;
  for (i = 0; i < 24; i++) {
    digitalWrite(SCK, HIGH);
    Count = Count << 1;
    digitalWrite(SCK, LOW);
    if (digitalRead(DT))
      Count++;
  }
  digitalWrite(SCK, HIGH);
  Count = Count ^ 0x800000;
  digitalWrite(SCK, LOW);
  return (Count);
}


void setup() {

  Serial.begin(9600);
  while (!Serial)
    ;
  pinMode(buttonPROTECT, INPUT_PULLUP);
  pinMode(PIN_LED_ROUGE, OUTPUT);  // onfiguration des sortie des lED
  pinMode(PIN_LED_VERTE, OUTPUT);  //configuration des sortie des lED
  pinMode(SCK, OUTPUT);
  pinMode(sw, INPUT_PULLUP);
  LCD.backlight();
  LCD.init();  // initialize the lcd
  //LCD.begin(0, 0);
  LCD.setCursor(5, 0);
  LCD.print(" PIEZO ");
  LCD.setCursor(3, 1);
  LCD.print(" APPLICATION ");
  LCD.setCursor(4, 2);
  LCD.print(" EQUIPE 405 ");
  LCD.setCursor(13, 3);
  LCD.print(" by NTA ");
  delay(8000);
  LCD.clear();
  calibrate();



  //Init Serial USB
  pinMode(swPin, INPUT_PULLUP);
  Serial.begin(9600);
  while (!Serial)
    ;
  Serial.println("LimitedRotator example for the RotaryEncoder library.");
  encoder.setPosition(10 / ROTARYSTEPS);  // start with the value of 10.
}  // setup()


// Read the current position of the encoder and print out when changed.
void loop() {
  ///////////////////////////////////////CALIBR
  buttonstate = digitalRead(buttonPROTECT);
  count = readCount();
  int P = (((count - sample) / val) - 2 * ((count - sample) / val));
  LCD.setCursor(0, 0);  // place le curseur au 1er caractère de la 2nde ligne
  LCD.print("Poids APPL :  ");
  LCD.setCursor(13, 0);
  LCD.print(P * (-1));
  LCD.print("g ");

  // affiche le message de l'encoduer sur LCD
  LCD.setCursor(0, 1);
  LCD.print("Consigne :");

  LCD.setCursor(10, 1);
  LCD.print(valeur);
  LCD.print("tr/min ");

  LCD.setCursor(0, 2);
  LCD.print("Choix : ");


  if (digitalRead(sw) == 0) {
    val = 0;
    sample = 0;
    P = 0;
    count = 0;
    calibrate();
  }
  //delay(5);// le temps pour l'encodeur avant de faire une boucle
  if (millis() - prevMillis > 5) {
    prevMillis = millis();
    encoder.tick();
  }

  // get the current physical position and calc the logical position
  int newPos = encoder.getPosition() * ROTARYSTEPS;

  if (newPos < ROTARYMIN) {
    encoder.setPosition(ROTARYMIN / ROTARYSTEPS);
    newPos = ROTARYMIN;

  } else if (newPos > ROTARYMAX) {
    encoder.setPosition(ROTARYMAX / ROTARYSTEPS);
    newPos = ROTARYMAX;
  }  // if

  if (lastPos != newPos) {
    LCD.setCursor(8, 2);
    LCD.println(" ");
    Serial.print(" ");
    LCD.setCursor(8, 2);
    LCD.print(newPos);

    Serial.println(" | Choix : ");
    Serial.println(newPos);
    lastPos = newPos;
  }  // if

  swState = digitalRead(swPin);
  if (swState == LOW && swLast == HIGH) {
    valeur = newPos;
    LCD.setCursor(13, 1);
    LCD.print(" ");
    Serial.print(" ");
    Serial.println("Rotary pressed");
    //delay(100);//debounce
    //le temps pour l'encodeur avant de faire une boucle

    if (millis() - prevMillis > 10) {
      prevMillis = millis();
    }
  }

  ////////////////////////////////////////////////////////////moteur
  BP_Etat = digitalRead(Broche_Marche_Arret);  // permet d'allumer ou eteindre le moteur
  Serial.print("Etat BP ");
  Serial.print(BP_Etat);

  //digitalWrite (Broche_Moteur, HIGH);
  POT_Valeur = analogRead(Broche_POT);  //permet de relever la valeur du potentiometre
  Serial.print(" | Valeur POT: ");
  Serial.print(POT_Valeur);

  Vitesse_De_Rotation();


  // ALgorithme télérupteur
  buttonstate = digitalRead(buttonPROTECT);
  if (buttonstate == HIGH) {
    if ((BP_Etat == HIGH) && (BP_Etat_Pre == LOW))  // permet au bouton poussoir de fonctionner sur front
    {
      Moteur = 1 - Moteur;
    }

    BP_Etat_Pre = BP_Etat;

    if (Moteur == 1) {
      analogWrite(Broche_Moteur, Sortie_PWM);
      LCD.setCursor(0, 3);
      LCD.print(" Moteur  RUN ");
      Serial.println("  | Moteur MARCHE ");
    }

    else {
      digitalWrite(Broche_Moteur, LOW);
      LCD.setCursor(0, 3);
      LCD.print(" Moteur STOP ");
      Serial.println("  | Moteur ARRET ");
    }
  }

  else

  {
    digitalWrite(Broche_Moteur, LOW);
    LCD.setCursor(0, 3);
    LCD.print(" close capot ");
    ///////////////////////////////////////LED1
    static unsigned long dernierRouge = 0, dernierverte = 0;

    if ((millis() - dernierverte) >= DEMI_PERIODE_VERTE) {
      dernierverte = dernierverte + DEMI_PERIODE_VERTE;
      basculeLED(PIN_LED_VERTE);
    }
    ///////////////////////////////////////
  }


}  // loop ()


void calibrate() {

  static unsigned long dernierRouge = 0;
  if ((millis() - dernierRouge) >= DEMI_PERIODE_ROUGE) {
    dernierRouge = dernierRouge + DEMI_PERIODE_ROUGE;
    basculeLED(PIN_LED_ROUGE);
  }
  LCD.backlight();  // active le rétro-éclairage
  LCD.clear();
  LCD.setCursor(3, 1);
  LCD.print("Calibrage...");
  LCD.setCursor(5, 2);
  LCD.print("Please Wait...");

  for (int i = 0; i < 100; i++) {
    count = readCount();
    sample += count;
  }
  sample /= 100;

  LCD.clear();
  LCD.setCursor(1, 1);
  LCD.print("pressez la cellule");
  LCD.setCursor(8, 2);
  LCD.print(" de");
  LCD.setCursor(7, 3);
  LCD.print("charge");
  count = 0;
  while (count < 1000)  //
  {

    count = readCount();
    count = sample - count;
  }
  LCD.clear();
  LCD.setCursor(4, 2);
  LCD.print("Please Wait....");
  delay(2000);
  for (int i = 0; i < 100; i++) {
    count = readCount();
    val += sample - count;
  }
  val = val / 100.0;
  val = val / 100.0;  // effectuer la premiere fapper a 20tr/min
  LCD.clear();
}


void Vitesse_De_Rotation() {
  a = 5.0 / 1023.0;      // le calcul du coef directeur
  Tension = a * valeur;  // pour convertir la vaaleur du POT en Tension
  Serial.print("| Tension: ");
  Serial.println(Tension);

  Sortie_PWM = valeur / 4;  // gerer la sortie du PWM, 1023/4= 255.75 alors l'entree ANA est de 0 à 1023 et la sortie PWM varie de 0 à 255
  Serial.print(" | Sortie PWM: ");
  Serial.println(Sortie_PWM);


  b = 100.0 / 255.0;  // calcul du coef directeur equation 0-100% 0-255
  Pourcentage_Sortie_PWM = b * Sortie_PWM;
  // Serial.print(" |Pourcentage_Sortie_PWM:  ");
  // Serial.print(Pourcentage_Sortie_PWM);

  Vitesse_MCC = 1000 * Tension;  // gerer la sortie du PWM, 1023/4= 255.75 alors l'entree ANA est de 0 à 1023 et la sortie PWM varie de 0 à 255
  Serial.print(" | Vitesse MCC : ");
  Serial.println(Vitesse_MCC);

  Val_piezo = analogRead(A5);
  Tension_piezo = a * Val_piezo;  // pour convertir la vaaleur dU PIEZO en Tension
  Serial.print("| Valeur piezo: ");
  Serial.println(Tension_piezo);

  int P = (((count - sample) / val) - 2 * ((count - sample) / val));
  Serial.print(" |Poids APPL");
  Serial.print(" P");
}
13

bonsoir, @dounexaf

pour commencer, bravo, c'est une excellente habitude de mettre des commentaires, mais tu devrais les lier aux [blocs d']outils auxquels ils se rapportent (j'y reviens plus loin ...)

puisque ton .INO est viable (si tu reçois les données auxquelles tu t'attends dans le Moniteur Série c'est qu'il fonctionne) je ne vais m'occuper que du VI.

pour le code-source C/C++, si quelqu'un d'autre se penche dessus (et les candidats ne doivent pas manquer sur ce forum) il pourra sans doute te conseiller d'autres façons d'écrire ou de faire, je me contenterai juste d'un détail : en ligne 39 tu déclares par exemple un bool State_bottom que tu n'utilises nulle part ailleurs ...

je vais maintenant lister ce qui me gène dans ton VI (ne le prends pas mal, même si mes propos te semblent un peu brusques, on m'a souvent reproché mon manque de tact ...)

ci-dessous, la liste des variables locales que tu utilises :

variables locales
variables locales670×670 9.85 KB

(cette liste ne contient que les objets pour lesquels tu utilises des variables locales, pas ceux qui ne possèdent qu’une seule occurrence dans ton VI, il se peut que d’autres objets portent également des noms identiques, je ne suis pas allé aussi loin)
LabVIEW sait gérer des objets différents aux noms identiques mais c’est dangereux car tu peux très bien ne pas avoir attribué la bonne variable locale à l’objet qui doit lui être associé : modifie donc les noms, pour qu’ils soient tous différents.
si, sur ta façade, deux objets doivent avoir le même libellé, préfère dans ce cas l’affichage de l’attribut Caption à celui du Label (qui correspond au nom de l’objet).
peut-être même que certains de ces objets devraient être les mêmes mais que tu t’es emmêlé les pinceaux : tu as du travail pour retomber sur tes pattes, mais c’est indispensable.

un exemple d’ambiguïté :
2 graph différents

tu as ci-dessus (dans ton Case "tension piézo fonction de…") une écriture dans un Graph et en même temps dans sa propre variable locale, alors que ci-dessous
2 mêmes graph

(dans l’autre cas du même Case) tu écris dans l’autre Graph et la variable locale du premier !
je ne sais pas où est l’erreur, mais tu la trouveras …

autre truc pas très joli :
poids

on ne sait pas d’où viennent et où vont certains flux.
pour nettoyer ton diagramme, il existe ce bouton, c’est un peu comme Ctrl-T dans l’IDE Arduino :
clean up

MAIS attention avant de t’en servir !
je te complimentais plus haut pour les commentaires, mais ils sont sous forme de texte libre et le nettoyage automatique ne les gardera pas à proximité des objets qu’ils concernent.
pour lier objets et commentaires je te conseille d’utiliser la Flat Sequence, comme ceci :
Flat Sequence Subdiagram Label

(j’ai regroupé au pif, le bloc n’est pas forcément correct)
en faisant un bloc des objets qui constituent une même fonction, non seulement ils resteront groupés visuellement, mais tu pourras ainsi utiliser le Subdiagram Label de la Flat Sequence qui, lui, ne bougera pas lors du nettoyage par rapport au reste de la fonction.

toujours dans cette dernière image :
le Feedback Node est un outil dangereux (je lui préfère le Shift Register, dont le comportement est prévisible, mais on verra ça une autre fois …)
de plus, je ne comprends pas ce que tu cherches à réaliser avec, sur un Decimal String To Number, en lui imposant une valeur par défaut en fonction de la donnée elle-même ? j’avoue que je ne vois pas ce que ça peut produire …

je m'arrête là, tu as déjà pas mal de boulot avec ces premières corrections à apporter.

la prochaine fois, fournis-moi un exemple des données telles qu'elles apparaissent dans le Moniteur Série (et, donc, telles qu'elles sont reçues par LabVIEW) : j'aimerais pouvoir effectuer des essais.
une explication sur les résultats espérés dans les affichages serait aussi la bienvenue.

bonne soirée, et porte-toi bien.