Exécution d'instructions en parallèle

Salut chers tous ! Je suis en train de réaliser un petit projet d'un ventilateur ou respirateur. Il est composé d'un ballon qui est pressé par un moteur pour pousser de l'air dans les voies respiratoires du patient. Je veux y associer un capteur max30100 pour afficher le nombre de battements cardiaques par minute ainsi que le taux d'oxygène (spO2) dans le sang du patient. Le tout est évidemment piloté par une carte arduino mega... Séparemment (commande moteur et acquisition des données du capteur) les choses marchent, mais quand je les mets ensemble, le capteur n'envoie plus les données actualisées, il n'envoie que des 0 pour toutes les valeurs.... Je ne suis qu'un débutant en arduno, un coup de pouce me ferait du bien. Voici le code que j'utilise :

#include <Wire.h>
#include "MAX30100_PulseOximeter.h" //librairie capteur

#define REPORTING_PERIOD_MS     200 //capteur
PulseOximeter pox;
uint32_t tsLastReport = 0;
double spo2, bpm;


#define relaisAv1 4
#define relaisAv2 5
#define relaisAr1 2
#define relaisAr2 3
int temps=300;
const int finCourseAv= 7;
const int finCourseAr =8;




int mosfet=6;
int pinPot = A5;

void setup() {
  Serial.begin(115200);
  Serial.print("Initializing pulse oximeter..");
  if (!pox.begin()) {
        Serial.println("FAILED");
        for(;;);
   } else {
        Serial.println("SUCCESS");
    }
  // put your setup code here, to run once:
  pinMode(relaisAv1, OUTPUT);
  pinMode(relaisAv2, OUTPUT);
  pinMode(relaisAr1, OUTPUT);
  pinMode(relaisAr2, OUTPUT);
  pinMode(finCourseAv, INPUT);
  pinMode(finCourseAr, INPUT);
  

  pinMode(mosfet, OUTPUT);
  digitalWrite(relaisAv1, HIGH);
  
  
}

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

   int b1 = digitalRead(7);
  int b2 = digitalRead(8);

  pox.update();
    if (millis() - tsLastReport > REPORTING_PERIOD_MS) {
    Serial.print("Heart rate:");
    Serial.print(pox.getHeartRate());
    Serial.print("bpm / SpO2:");
    Serial.print(pox.getSpO2());
    Serial.println("%");

     tsLastReport = millis();
    }
    mouvMoteur ();
  
 
  int valPot=analogRead(pinPot);
  int valMoteur = map(valPot, 0, 1023, 0, 255);

  analogWrite(mosfet, valMoteur);
  
}

void onBeatDetected()
{
    Serial.println("Beat!");
}

void mouvMoteur () {

  int b1 = digitalRead(7);
  int b2 = digitalRead(8);
   digitalWrite(relaisAv1, b1 ? LOW : HIGH);
  digitalWrite(relaisAv2, b1 ? LOW : HIGH);
  digitalWrite(relaisAr1, LOW);
  digitalWrite(relaisAr2, LOW);
  delay(temps);
  
  digitalWrite(relaisAv1, LOW);
  digitalWrite(relaisAv2, LOW);
  digitalWrite(relaisAr1, LOW);
  digitalWrite(relaisAr2, LOW);
  delay(1000);
  
  digitalWrite(relaisAv1, LOW);
  digitalWrite(relaisAv2, LOW);
  digitalWrite(relaisAr1, b2 ? LOW : HIGH);
  digitalWrite(relaisAr2, b2 ? LOW : HIGH);
  delay(temps);

  digitalWrite(relaisAv1, LOW);
  digitalWrite(relaisAv2, LOW);
  digitalWrite(relaisAr1, LOW);
  digitalWrite(relaisAr2, LOW);
  delay(1000);
  }


Quand vous appelez mouvMoteur() votre code est bloqué pendant 2.,6 secondes, il ne fait rien d'autre...

il faut virer les délais, un peu comme vous avez fait avec

vous testez si c'est le moment d'agir.

Heu... on peut espérer avoir du matos un peu plus « pro » si déjà on est obligé de passer par la case réanimation ?

J'ai rien contre les projets en DIY, mais j'espère que c'est juste pour étudier le principe, pas pour y brancher quelqu'un.

Merci de votre réaction... Mon souci, c'est qu'à mon niveau, je ne sais pas bien me servir de millis()...

Le plus simple dans un premier temps et de mettre en commentaire la ligne 64 qui appels ta fonction.
Car normalement tu ne devrais avoir aucun affichage pendant un peu moins de 3s, mais pas un affichage avec uniquement des 0.

pourrais tu nous donner ta sortie série ?

A la grande surprise, la carte semble ne plus envoyer de données.... Voici ce que donne la sortie :

tu as désactiver l'appel de ta fonction mouvMoteur?

Faire exécuter des tâches en "parallèle" à un Arduino n'est pas forcément facile. J'ai fait un petit tuto ici :

Dans ton cas, la fonction mouvMoteur va poser des problèmes parce qu'elle fait 4 choses en série avec des délais entre chacune. Donc pour adapter ton problème à ce que j'explique dans le tuto, il faudrait couper cette fonction en 4 fonctions "atomiques" et faire une petite machine d'états pour savoir à quel moment appeler laquelle.

Ce n'est pas forcément très compliqué, il faut bien comprendre le fonctionnement d'une machine d'états. @J-M-L a fait un tuto très bien expliqué sur ce domaine. Je pense qu'il est là :

Bonne lecture !

Oui... Et la sortie devient bonne

C'est donc bien ce que t'indiquais @J-M-L et @lesept .
Ta fonction mouvMoteur bloque la librairie MAX30100_PulseOximeter dans ses calcules.
Tu n'a d'autre moyen que de passer par une machine à état, le mieux à mon avis est de suivre le tuto de @J-M-L que @lesept t'a indiqué.

Le principe est d'avoir une variable qui t'indique l'état courant et donc dans ton cas le temps que tu dois attendre avant de passer dans l'état suivant.

Merci...
Je venais de faire ce petit code :

unsigned long prevTime = millis();

#define relaisAv1 4
#define relaisAv2 5
#define relaisAr1 2
#define relaisAr2 3
const int finCourseAv= 7;
const int finCourseAr =8;
const int mosfet=6;
int compteur = 0, tpsMvt = 2000, tpsRepos;


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

  Serial.begin(115200);
  pinMode(relaisAv1, OUTPUT);
  pinMode(relaisAv2, OUTPUT);
  pinMode(relaisAr1, OUTPUT);
  pinMode(relaisAr2, OUTPUT);
  pinMode(finCourseAv, INPUT);
  pinMode(finCourseAr, INPUT);

  pinMode(mosfet, OUTPUT);
}

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

  unsigned long currentTime = millis();
  int b1 = digitalRead(7);
  int b2 = digitalRead(8);
  if(1000<currentTime-prevTime<=2000){
      digitalWrite(relaisAv1, b1 ? LOW : HIGH);
      digitalWrite(relaisAv2, b1 ? LOW : HIGH);
      digitalWrite(relaisAr1, LOW);
      digitalWrite(relaisAr2, LOW);
      Serial.println("moteur en avance");
    }

  if(2001<currentTime-prevTime<=3000){
      digitalWrite(relaisAv1, LOW);
      digitalWrite(relaisAv2, LOW);
      digitalWrite(relaisAr1, b2 ? LOW : HIGH);
      digitalWrite(relaisAr2, b2 ? LOW : HIGH);
      Serial.println("moteur en arriere");
      
    }

    if(3001<currentTime-prevTime<=4000){
      digitalWrite(relaisAv1, LOW);
      digitalWrite(relaisAv2, LOW);
      digitalWrite(relaisAr1, LOW);
      digitalWrite(relaisAr2, LOW);
      Serial.println("moteur au repos");
      prevTime = currentTime;
    }
   
}

Mais en le testant, il ne respecte pas les délais indiqués, il est très rapide. Tellement rapide que les relais ne commutent pas mais produisent un son à la place

Si vous lisez l’anglais il y a des exemples

Sinon c’est typiquement une définition de programme qui se prête bien à la programmation par machine à états (cf mon tuto éventuellement)

Je pense que cette ligne doit être après l'accolade qui suit, avant la dernière accolade de la fonction