Interruption problèmes

flafvien · March 11, 2025, 8:50am

Bonjour, je rencontre actuellement des problèmes sur mon code au niveau des interruptions pendant la lecture de mes phases ou de cellule de hall. J'obtiens des valeurs aberrantes du style le double de la période, etc...

Si quelqu'un pouvait m'aider à réduire mon code et le stabiliser, merci

#include <SPI.h>//appel de la librairie de communication spi 
#include <GD2.h>//appel de la librairie écran

#define SCREEN_WIDTH  800  // Largeur de l'écran
#define SCREEN_HEIGHT 480  // Hauteur de l'écran

// Coordonnées et dimensions du bouton virtuel
#define BUTTON_X  580   // Position X du bouton
#define BUTTON_Y  50   // Position Y du bouton
#define BUTTON_W  130   // Largeur du bouton
#define BUTTON_H  40    // Hauteur du bouton

const int Pmax=110000;
const int Pmin=90000;

//dimmension scrollbar
int scrollbarX = BUTTON_X;
int scrollbarY = BUTTON_Y + BUTTON_H + 30;  // Positionnement de la scrollbar sous le bouton avec un petit espace
int scrollbarW = BUTTON_W;
int scrollbarH = 30;  // Hauteur de la scrollbar
uint16_t scrollbarVal = 0;  // Valeur initiale de la scrollbar
uint16_t scrollbarSize = 10;  // Taille du curseur de la scrollbar
uint16_t scrollbarRange = 150;  // Range de la scrollbar


// Déclaration des broches pour les signaux
const int Phase1 = 13;               // Utilisation de la broche P1_Pin
const int Hall_PulsePin1 = 2;       // Utilisation de la broche H1_Pin
const int Phase2 = 12;               // Utilisation de la broche P2_Pin
const int Hall_PulsePin2 = 6;        // Utilisation de la broche H2_Pin
const int Phase3 = 7;                // Utilisation de la broche P3_Pin
const int Hall_PulsePin3 = 8;        // Utilisation de la broche H3_Pin
const int Phase1_Fall = 9;           // Utilisation de la broche P1_Pin
const int Hall_PulsePin1_Fall = 15;  // Utilisation de la broche H1_Pin
const int Phase2_Fall = 3;           // Utilisation de la broche P2_Pin
const int Hall_PulsePin2_Fall = 1;   // Utilisation de la broche H2_Pin
const int Phase3_Fall = 0;           // Utilisation de la broche P3_Pin
const int Hall_PulsePin3_Fall = 11;  // Utilisation de la broche H3_Pin
const int SS_PIN = 10;  // Déclaration de la broche SS

const int x= 380; //Valeur affichage écran longeur

// Indices de période pour chaque phase
static int periodIndex_Phase1 = 0;
static int periodIndex_Phase2 = 0;
static int periodIndex_Phase3 = 0;
static int periodIndex_Hall1 = 0;
static int periodIndex_Hall2 = 0;
static int periodIndex_Hall3 = 0;
//falling
static int periodIndex_Phase1_fall = 0;
static int periodIndex_Phase2_fall = 0;
static int periodIndex_Phase3_fall = 0;
static int periodIndex_Hall1_fall = 0;
static int periodIndex_Hall2_fall = 0;
static int periodIndex_Hall3_fall = 0;

// Nombre d'éléments stockés dans chaque tableau
int numStored_Phase1 = 0;
int numStored_Phase2 = 0;
int numStored_Phase3 = 0;
int numStored_Hall1 = 0;
int numStored_Hall2 = 0;
int numStored_Hall3 = 0;
//falling
int numStored_Phase1_fall = 0;
int numStored_Phase2_fall = 0;
int numStored_Phase3_fall = 0;
int numStored_Hall1_fall = 0;
int numStored_Hall2_fall = 0;
int numStored_Hall3_fall = 0;

// Périodes des phases
unsigned long period_Hall_1 = 0;
unsigned long period_Hall_2 = 0;
unsigned long period_Hall_3 = 0;
unsigned long period_Phase_1 = 0;
unsigned long period_Phase_2 = 0;
unsigned long period_Phase_3 = 0;
//falling
unsigned long period_Hall_1_fall = 0;
unsigned long period_Hall_2_fall = 0;
unsigned long period_Hall_3_fall = 0;
unsigned long period_Phase_1_fall = 0;
unsigned long period_Phase_2_fall = 0;
unsigned long period_Phase_3_fall = 0;

// Temps de début des impulsions
volatile unsigned long startTime_Phase_1 = 0;
volatile unsigned long stopTime_Phase_1 = 0;
volatile unsigned long startTime_Hall_1 = 0;
volatile unsigned long stopTime_Hall_1 = 0;
volatile unsigned long startTime_Phase_2 = 0;
volatile unsigned long stopTime_Phase_2 = 0;
volatile unsigned long startTime_Hall_2 = 0;
volatile unsigned long stopTime_Hall_2 = 0;
volatile unsigned long startTime_Phase_3 = 0;
volatile unsigned long stopTime_Phase_3 = 0;
volatile unsigned long startTime_Hall_3 = 0;
volatile unsigned long stopTime_Hall_3 = 0;
//temps de début d'impulsions pour front descendant
volatile unsigned long startTime_Phase_1_fall = 0;
volatile unsigned long stopTime_Phase_1_fall = 0;
volatile unsigned long startTime_Hall_1_fall = 0;
volatile unsigned long stopTime_Hall_1_fall = 0;
volatile unsigned long startTime_Phase_2_fall = 0;
volatile unsigned long stopTime_Phase_2_fall = 0;
volatile unsigned long startTime_Hall_2_fall = 0;
volatile unsigned long stopTime_Hall_2_fall = 0;
volatile unsigned long startTime_Phase_3_fall = 0;
volatile unsigned long stopTime_Phase_3_fall = 0;
volatile unsigned long startTime_Hall_3_fall = 0;
volatile unsigned long stopTime_Hall_3_fall = 0;

// Détection des impulsions
volatile bool phase1_detected = false;
volatile bool hall1_detected = false;
volatile bool phase2_detected = false;
volatile bool hall2_detected = false;
volatile bool phase3_detected = false;
volatile bool hall3_detected = false;
//falling
volatile bool phase1_detected_fall = false;
volatile bool hall1_detected_fall = false;
volatile bool phase2_detected_fall = false;
volatile bool hall2_detected_fall = false;
volatile bool phase3_detected_fall = false;
volatile bool hall3_detected_fall = false;

// Déclaration de la constante pour le debounce
const unsigned long debounceDelay = 1000;  // 1000 ms en microsecondes

// Déclaration des temps d'interruption pour debounce
volatile unsigned long lastInterruptTime_Phase1 = 0;
volatile unsigned long lastInterruptTime_Phase2 = 0;
volatile unsigned long lastInterruptTime_Phase3 = 0;
volatile unsigned long lastInterruptTime_Phase1_Fall = 0;
volatile unsigned long lastInterruptTime_Phase2_Fall = 0;
volatile unsigned long lastInterruptTime_Phase3_Fall = 0;

// Initialisation de la somme des angles et du compteur d'angles
float minValue1, maxValue1, minValue2, maxValue2, minValue3, maxValue3;
float minValue1_fall, maxValue1_fall, minValue2_fall, maxValue2_fall, minValue3_fall, maxValue3_fall;
float sumAngles, sumAngles_fall;
int angleCount, angleCount_fall;
const int numPeriods = 12;  // Exemple, à ajuster selon vos besoins

// Déclarations des tableaux pour les périodes (à définir)
float periods_Hall1[numPeriods], periods_Phase1[numPeriods];
float periods_Hall2[numPeriods], periods_Phase2[numPeriods];
float periods_Hall3[numPeriods], periods_Phase3[numPeriods];

float periods_Hall1_fall[numPeriods], periods_Phase1_fall[numPeriods];
float periods_Hall2_fall[numPeriods], periods_Phase2_fall[numPeriods];
float periods_Hall3_fall[numPeriods], periods_Phase3_fall[numPeriods];

void resetMicrocontroller() { // Fonction pour simuler un reset du microcontrôleur
  __disable_irq(); // Désactiver les interruptions
  NVIC_SystemReset(); // Effectuer le reset du système
}

void setup() {
  GD.begin();  // Initialisation de l'écran
  delay(3000); // Attendre 3 secondes avant de commencer la calibration

  // Afficher un message avant la calibration
  GD.ClearColorRGB(0x000000);  // Fond noir
  GD.Clear();
  GD.cmd_text(400, 240, 31, OPT_CENTER, "Realiser la calibration");
  GD.swap();  // Forcer l'affichage du texte
  delay(3000);  // Attendre 3 secondes pour permettre à l'utilisateur de voir le message

  // Lancer la calibration
  GD.ClearColorRGB(0xFFFFFF);  // Fond blanc
  GD.Clear();
  GD.cmd_calibrate();  // Exécuter la calibration
  GD.swap();  // Forcer l'affichage pendant la calibration
  delay(3000);  // Attendre 3 secondes après la calibration 

    // Configuration des broches en entrée
  pinMode(Phase1, INPUT);
  pinMode(Hall_PulsePin1, INPUT);
  pinMode(Phase2, INPUT);
  pinMode(Hall_PulsePin2, INPUT);
  pinMode(Phase3, INPUT);
  pinMode(Hall_PulsePin3, INPUT);
  pinMode(Phase1_Fall, INPUT);
  pinMode(Hall_PulsePin1_Fall, INPUT);
  pinMode(Phase2_Fall, INPUT);
  pinMode(Hall_PulsePin2_Fall, INPUT);
  pinMode(Phase3_Fall, INPUT);
  pinMode(Hall_PulsePin3_Fall, INPUT);

  // Initialisation des valeurs minimales et maximales
  minValue1 = minValue2 = minValue3 = 360.0;
  maxValue1 = maxValue2 = maxValue3 = -360.0;
  minValue1_fall = minValue2_fall = minValue3_fall = 360.0;
  maxValue1_fall = maxValue2_fall = maxValue3_fall = -360.0;
  angleCount = angleCount_fall = 0;
  sumAngles = sumAngles_fall = 0.0;

  // Démarrage de la communication série
  Serial.begin(115200);

  // Attachement des interruptions pour détecter les fronts montants
  attachInterrupt(digitalPinToInterrupt(Phase1), countPulse_Phase1, RISING);
  attachInterrupt(digitalPinToInterrupt(Phase2), countPulse_Phase2, RISING);
  attachInterrupt(digitalPinToInterrupt(Phase3), countPulse_Phase3, RISING);
  attachInterrupt(digitalPinToInterrupt(Hall_PulsePin1), countPulse_Hall1, RISING);
  attachInterrupt(digitalPinToInterrupt(Hall_PulsePin2), countPulse_Hall2, RISING);
  attachInterrupt(digitalPinToInterrupt(Hall_PulsePin3), countPulse_Hall3, RISING);

  // Attachement des interruptions pour détecter les fronts descendants sur les broches supplémentaires
  attachInterrupt(digitalPinToInterrupt(Hall_PulsePin1_Fall), countPulse_Hall1_fall, FALLING);
  attachInterrupt(digitalPinToInterrupt(Hall_PulsePin2_Fall), countPulse_Hall2_fall, FALLING);
  attachInterrupt(digitalPinToInterrupt(Hall_PulsePin3_Fall), countPulse_Hall3_fall, FALLING);
  attachInterrupt(digitalPinToInterrupt(Phase1_Fall), countPulse_Phase1_fall, FALLING);
  attachInterrupt(digitalPinToInterrupt(Phase2_Fall), countPulse_Phase2_fall, FALLING);
  attachInterrupt(digitalPinToInterrupt(Phase3_Fall), countPulse_Phase3_fall, FALLING);
  Serial.print("Programme initialisé");
}

void loop() {
  GD.get_inputs();  // Mettre à jour les entrées tactiles

  // Détecter la pression du bouton
  if (GD.inputs.x != -32768) {  // Si un toucher est détecté
    int x = GD.inputs.x;
    int y = GD.inputs.y;

    // Vérifiez si les coordonnées sont dans la zone du bouton
    if (x >= BUTTON_X && x <= (BUTTON_X + BUTTON_W) && y >= BUTTON_Y && y <= (BUTTON_Y + BUTTON_H)) {
      resetMicrocontroller();  // Réinitialiser la carte
    }
    // Vérifiez si les coordonnées sont dans la zone de la scrollbar
        if (x >= scrollbarX && x <= (scrollbarX + scrollbarW) && y >= scrollbarY && y <= (scrollbarY + scrollbarH)) {
            // Calculer la nouvelle valeur de la scrollbar en fonction de la position du toucher
            scrollbarVal = map(x, scrollbarX, scrollbarX + scrollbarW, 0, scrollbarRange - scrollbarSize);

            // Limiter la valeur de scrollbarVal pour éviter les débordements
            scrollbarVal = constrain(scrollbarVal, 0, scrollbarRange - scrollbarSize);
        }
  }

  if (numStored_Hall1 == numPeriods && numStored_Hall2 == numPeriods && numStored_Hall3 == numPeriods && numStored_Phase1 == numPeriods && numStored_Phase2 == numPeriods && numStored_Phase3 == numPeriods && numStored_Hall1_fall == numPeriods && numStored_Hall2_fall == numPeriods && numStored_Hall3_fall == numPeriods && numStored_Phase1_fall == numPeriods && numStored_Phase2_fall == numPeriods && numStored_Phase3_fall == numPeriods) {
    calculateAngle();
    // Réinitialiser les tableaux après avoir calculé les angles
    numStored_Hall1 = 0;
    memset(periods_Hall1, 0, sizeof(periods_Hall1));
    numStored_Hall2 = 0;
    memset(periods_Hall2, 0, sizeof(periods_Hall2));
    numStored_Hall3 = 0;
    memset(periods_Hall3, 0, sizeof(periods_Hall3));
    numStored_Phase1 = 0;
    memset(periods_Phase1, 0, sizeof(periods_Phase1));
    numStored_Phase2 = 0;
    memset(periods_Phase2, 0, sizeof(periods_Phase2));
    numStored_Phase3 = 0;
    memset(periods_Phase3, 0, sizeof(periods_Phase3));
    //falling reset fronts descendants
    numStored_Hall1_fall = 0;
    memset(periods_Hall1_fall, 0, sizeof(periods_Hall1_fall));
    numStored_Hall2_fall = 0;
    memset(periods_Hall2_fall, 0, sizeof(periods_Hall2_fall));
    numStored_Hall3_fall = 0;
    memset(periods_Hall3_fall, 0, sizeof(periods_Hall3_fall));
    numStored_Phase1_fall = 0;
    memset(periods_Phase1_fall, 0, sizeof(periods_Phase1_fall));
    numStored_Phase2_fall = 0;
    memset(periods_Phase2_fall, 0, sizeof(periods_Phase2_fall));
    numStored_Phase3_fall = 0;
    memset(periods_Phase3_fall, 0, sizeof(periods_Phase3_fall));

    delay(2000);
  }
}

void countPulse_Hall1() {
  if (!hall1_detected && phase1_detected) {
    // Détection suivante de Hall1, calcul de la période entre les fronts montants
    stopTime_Hall_1 = micros();
    period_Hall_1 = stopTime_Hall_1 - startTime_Hall_1;
    hall1_detected = true;
    // Stocker la période détectée dans le tableau correspondant si elle est supérieure à 100000
    if (period_Hall_1 >= 100) {
      periods_Hall1[periodIndex_Hall1] = period_Hall_1;
      periodIndex_Hall1 = (periodIndex_Hall1 + 1) % numPeriods;
      if (numStored_Hall1 < numPeriods) {
        numStored_Hall1++;
      }
    }
  } else {
    hall1_detected = false;
  }
}

void countPulse_Hall2() {
  if (!hall2_detected && phase2_detected) {
    // Détection suivante de Hall2, calcul de la période entre les fronts montants
    stopTime_Hall_2 = micros();
    period_Hall_2 = stopTime_Hall_2 - startTime_Hall_2;
    hall2_detected = true;
    // Stocker la période détectée dans le tableau correspondant si elle est supérieure à 100000
    if (period_Hall_2 >= 100) {
      periods_Hall2[periodIndex_Hall2] = period_Hall_2;
      periodIndex_Hall2 = (periodIndex_Hall2 + 1) % numPeriods;
      if (numStored_Hall2 < numPeriods) {
        numStored_Hall2++;
      }
    }
  } else {
    hall2_detected = false;
  }
}

void countPulse_Hall3() {
  if (!hall3_detected && phase3_detected) {
    // Détection suivante de Hall3, calcul de la période entre les fronts montants
    stopTime_Hall_3 = micros();
    period_Hall_3 = stopTime_Hall_3 - startTime_Hall_3;
    hall3_detected = true;
    // Stocker la période détectée dans le tableau correspondant si elle est supérieure à 100000
    if (period_Hall_3 >= 100) {
      periods_Hall3[periodIndex_Hall3] = period_Hall_3;
      periodIndex_Hall3 = (periodIndex_Hall3 + 1) % numPeriods;
      if (numStored_Hall3 < numPeriods) {
        numStored_Hall3++;
      }
    }
  } else {
    hall3_detected = false;
  }
}

void countPulse_Phase1() {
  unsigned long currentTime_1r = micros();
  if (currentTime_1r - lastInterruptTime_Phase1 > debounceDelay) {
    lastInterruptTime_Phase1 = currentTime_1r;
    if (!phase1_detected && !hall1_detected) {
      // Première détection de Phase1, démarrage des deux timers
      startTime_Phase_1 = micros();
      startTime_Hall_1 = micros();
      phase1_detected = true;
    } else {
      // Détection suivante de Phase1, calcul de la période entre les fronts montants
      stopTime_Phase_1 = micros();
      period_Phase_1 = stopTime_Phase_1 - startTime_Phase_1;
      phase1_detected = false;
      // Stocker la période détectée dans le tableau correspondant si elle est supérieure à 100000
      if (period_Phase_1 >= Pmin && period_Phase_1 <= Pmax) {
        periods_Phase1[periodIndex_Phase1] = period_Phase_1;
        periodIndex_Phase1 = (periodIndex_Phase1 + 1) % numPeriods;
        if (numStored_Phase1 < numPeriods) {
          numStored_Phase1++;
        }
      }
    }
  }
}

void countPulse_Phase2() {
  unsigned long currentTime_2r = micros();
  if (currentTime_2r - lastInterruptTime_Phase2 > debounceDelay) {
    lastInterruptTime_Phase2 = currentTime_2r;
    if (!phase2_detected && !hall2_detected) {
      // Première détection de Phase2, démarrage des deux timers
      startTime_Phase_2 = micros();
      startTime_Hall_2 = micros();
      phase2_detected = true;
    } else {
      // Détection suivante de Phase2, calcul de la période entre les fronts montants
      stopTime_Phase_2 = micros();
      period_Phase_2 = stopTime_Phase_2 - startTime_Phase_2;

      phase2_detected = false;
      // Stocker la période détectée dans le tableau correspondant si elle est supérieure à 100000
      if (period_Phase_2 >= Pmin && period_Phase_2 <= Pmax) {
        periods_Phase2[periodIndex_Phase2] = period_Phase_2;
        periodIndex_Phase2 = (periodIndex_Phase2 + 1) % numPeriods;
        if (numStored_Phase2 < numPeriods) {
          numStored_Phase2++;
        }
      }
    }
  }
}

void countPulse_Phase3() {
  unsigned long currentTime_3r = micros();
  if (currentTime_3r - lastInterruptTime_Phase3 > debounceDelay) {
    lastInterruptTime_Phase3 = currentTime_3r;
    if (!phase3_detected && !hall3_detected) {
      // Première détection de Phase3, démarrage des deux timers
      startTime_Phase_3 = micros();
      startTime_Hall_3 = micros();
      phase3_detected = true;
    } else {
      // Détection suivante de Phase3, calcul de la période entre les fronts montants
      stopTime_Phase_3 = micros();
      period_Phase_3 = stopTime_Phase_3 - startTime_Phase_3;
      phase3_detected = false;
      // Stocker la période détectée dans le tableau correspondant si elle est supérieure à 100000
      if (period_Phase_3 >= Pmin && period_Phase_3 <= Pmax) {
        periods_Phase3[periodIndex_Phase3] = period_Phase_3;
        periodIndex_Phase3 = (periodIndex_Phase3 + 1) % numPeriods;
        if (numStored_Phase3 < numPeriods) {
          numStored_Phase3++;
        }
      }
    }
  }
}
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void countPulse_Hall1_fall() {
  if (!hall1_detected_fall && phase1_detected_fall) {
    // Détection suivante de Hall1, calcul de la période entre les fronts montants
    stopTime_Hall_1_fall = micros();
    period_Hall_1_fall = stopTime_Hall_1_fall - startTime_Hall_1_fall;

    hall1_detected_fall = true;
    // Stocker la période détectée dans le tableau correspondant si elle est supérieure à 100000
    if (period_Hall_1_fall >= 10) {
      periods_Hall1_fall[periodIndex_Hall1_fall] = period_Hall_1_fall;
      periodIndex_Hall1_fall = (periodIndex_Hall1_fall + 1) % numPeriods;
      if (numStored_Hall1_fall < numPeriods) {
        numStored_Hall1_fall++;
      }
    }
  } else {
    hall1_detected_fall = false;
  }
}

void countPulse_Hall2_fall() {
  if (!hall2_detected_fall && phase2_detected_fall) {
    // Détection suivante de Hall2, calcul de la période entre les fronts montants
    stopTime_Hall_2_fall = micros();
    period_Hall_2_fall = stopTime_Hall_2_fall - startTime_Hall_2_fall;

    hall2_detected_fall = true;
    // Stocker la période détectée dans le tableau correspondant si elle est supérieure à 100000
    if (period_Hall_2_fall >= 10) {
      periods_Hall2_fall[periodIndex_Hall2_fall] = period_Hall_2_fall;
      periodIndex_Hall2_fall = (periodIndex_Hall2_fall + 1) % numPeriods;
      if (numStored_Hall2_fall < numPeriods) {
        numStored_Hall2_fall++;
      }
    }
  } else {
    hall2_detected_fall = false;
  }
}

void countPulse_Hall3_fall() {
  if (!hall3_detected_fall && phase3_detected_fall) {
    // Détection suivante de Hall3, calcul de la période entre les fronts montants
    stopTime_Hall_3_fall = micros();
    period_Hall_3_fall = stopTime_Hall_3_fall - startTime_Hall_3_fall;

    hall3_detected_fall = true;
    // Stocker la période détectée dans le tableau correspondant si elle est supérieure à 100000
    if (period_Hall_3_fall >= 10) {
      periods_Hall3_fall[periodIndex_Hall3_fall] = period_Hall_3_fall;
      periodIndex_Hall3_fall = (periodIndex_Hall3_fall + 1) % numPeriods;
      if (numStored_Hall3_fall < numPeriods) {
        numStored_Hall3_fall++;
      }
    }
  } else {
    hall3_detected_fall = false;
  }
}

void countPulse_Phase1_fall() {
  unsigned long currentTime_1f = micros();
  if (currentTime_1f - lastInterruptTime_Phase1_Fall > debounceDelay) {
    lastInterruptTime_Phase1_Fall = currentTime_1f;
    if (!phase1_detected_fall && !hall1_detected_fall) {
      // Première détection de Phase1, démarrage des deux timers
      startTime_Phase_1_fall = micros();
      startTime_Hall_1_fall = micros();
      phase1_detected_fall = true;
    } else {
      // Détection suivante de Phase1, calcul de la période entre les fronts montants
      stopTime_Phase_1_fall = micros();
      period_Phase_1_fall = stopTime_Phase_1_fall - startTime_Phase_1_fall;
      phase1_detected_fall = false;
      // Stocker la période détectée dans le tableau correspondant si elle est supérieure à 100000
      if (period_Phase_1_fall >= Pmin && period_Phase_1_fall <= Pmax) {
        periods_Phase1_fall[periodIndex_Phase1_fall] = period_Phase_1_fall;
        periodIndex_Phase1_fall = (periodIndex_Phase1_fall + 1) % numPeriods;
        if (numStored_Phase1_fall < numPeriods) {
          numStored_Phase1_fall++;
        }
      }
    }
  }
}

void countPulse_Phase2_fall() {
    unsigned long currentTime_2f = micros();
    if (currentTime_2f - lastInterruptTime_Phase2_Fall > debounceDelay) {
        lastInterruptTime_Phase2_Fall = currentTime_2f;
        if (!phase2_detected_fall && !hall2_detected_fall) {
            // Première détection de Phase2, démarrage des deux timers
            startTime_Phase_2_fall = micros();
            startTime_Hall_2_fall = micros();
            phase2_detected_fall = true;
        } else {
            // Détection suivante de Phase2, calcul de la période entre les fronts montants
            stopTime_Phase_2_fall = micros();
            period_Phase_2_fall = stopTime_Phase_2_fall - startTime_Phase_2_fall;

            phase2_detected_fall = false;
            // Validation de la période détectée
            if (period_Phase_2_fall >= Pmin && period_Phase_2_fall <= Pmax ) {
                periods_Phase2_fall[periodIndex_Phase2_fall] = period_Phase_2_fall;
                periodIndex_Phase2_fall = (periodIndex_Phase2_fall + 1) % numPeriods;
                if (numStored_Phase2_fall < numPeriods) {
                    numStored_Phase2_fall++;
                }
            } 
        }
    }
}


void countPulse_Phase3_fall() {
  unsigned long currentTime_3f = micros();
  if (currentTime_3f - lastInterruptTime_Phase3_Fall > debounceDelay) {
    lastInterruptTime_Phase3_Fall = currentTime_3f;
    if (!phase3_detected_fall && !hall3_detected_fall) {
      // Première détection de Phase3, démarrage des deux timers
      startTime_Phase_3_fall = micros();
      startTime_Hall_3_fall = micros();
      phase3_detected_fall = true;
    } else {
      // Détection suivante de Phase3, calcul de la période entre les fronts montants
      stopTime_Phase_3_fall = micros();
      period_Phase_3_fall = stopTime_Phase_3_fall - startTime_Phase_3_fall;

      phase3_detected_fall = false;
      // Stocker la période détectée dans le tableau correspondant si elle est supérieure à 100000
      if (period_Phase_3_fall >= Pmin && period_Phase_3_fall <= Pmax ) {
        periods_Phase3_fall[periodIndex_Phase3_fall] = period_Phase_3_fall;
        periodIndex_Phase3_fall = (periodIndex_Phase3_fall + 1) % numPeriods;
        if (numStored_Phase3_fall < numPeriods) {
          numStored_Phase3_fall++;
        }
      }
    }
  }
}

void calculateAngle() {
  GD.ClearColorRGB(0x000000);
  GD.Clear();
  int y = 10;  // Position de départ sur l'écran pour l'affichage

  for (int i = 0; i < numPeriods; ++i) {

    // Calcul des angles pour le front montant
    float angle_phase1 = (static_cast<float>(periods_Hall1[i]) / periods_Phase1[i]) * 360;
    float angle_phase2 = (static_cast<float>(periods_Hall2[i]) / periods_Phase2[i]) * 360;
    float angle_phase3 = (static_cast<float>(periods_Hall3[i]) / periods_Phase3[i]) * 360;

    angle_phase1 = angle_phase1 >= 180 ? angle_phase1 - 360 : angle_phase1;
    angle_phase2 = angle_phase2 >= 180 ? angle_phase2 - 360 : angle_phase2;
    angle_phase3 = angle_phase3 >= 180 ? angle_phase3 - 360 : angle_phase3;

    // Compute absolute values for averaging
    float abs_angle_phase1 = abs(angle_phase1);
    float abs_angle_phase2 = abs(angle_phase2);
    float abs_angle_phase3 = abs(angle_phase3);

    // Mise à jour des valeurs minimales et maximales pour chaque angle
    if (angleCount == 0) {
      minValue1 = maxValue1 = angle_phase1;
      minValue2 = maxValue2 = angle_phase2;
      minValue3 = maxValue3 = angle_phase3;
    } else {
      minValue1 = min(minValue1, angle_phase1);
      maxValue1 = max(maxValue1, angle_phase1);
      minValue2 = min(minValue2, angle_phase2);
      maxValue2 = max(maxValue2, angle_phase2);
      minValue3 = min(minValue3, angle_phase3);
      maxValue3 = max(maxValue3, angle_phase3);
    }

    // Ajouter l'angle à la somme et incrémenter le compteur d'angles
    sumAngles += abs_angle_phase1 + abs_angle_phase2 + abs_angle_phase3;
    angleCount++;

    if (angleCount == numPeriods) {
    GD.cmd_text(10, y, 28, 0, "_____Front_Montant_____");
    y += 30;
      // Calculer la moyenne des angles en utilisant les valeurs absolues
      float moyenneAngle = sumAngles / (3 * numPeriods);  // Il y a 3 angles par période

      GD.cmd_text(10, y, 28, 0, "Moyenne des angles : ");
      GD.cmd_text(x, y, 28, 0, String(moyenneAngle).c_str());
      y += 30;

      GD.cmd_text(10, y, 28, 0, "Valeur minimale pour Hall1-Phase1 : ");
      GD.cmd_text(x, y, 28, 0, String(minValue1).c_str());
      y += 30;

      GD.cmd_text(10, y, 28, 0, "Valeur maximale pour Hall1-Phase1 : ");
      GD.cmd_text(x, y, 28, 0, String(maxValue1).c_str());
      y += 30;

      GD.cmd_text(10, y, 28, 0, "Valeur minimale pour Hall2-Phase2 : ");
      GD.cmd_text(x, y, 28, 0, String(minValue2).c_str());
      y += 30;

      GD.cmd_text(10, y, 28, 0, "Valeur maximale pour Hall2-Phase2 : ");
      GD.cmd_text(x, y, 28, 0, String(maxValue2).c_str());
      y += 30;

      GD.cmd_text(10, y, 28, 0, "Valeur minimale pour Hall3-Phase3 : ");
      GD.cmd_text(x, y, 28, 0, String(minValue3).c_str());
      y += 30;

      GD.cmd_text(10, y, 28, 0, "Valeur maximale pour Hall3-Phase3 : ");
      GD.cmd_text(x, y, 28, 0, String(maxValue3).c_str());
      y += 30;
      
      // Réinitialiser la somme et le compteur
      sumAngles = 0;
      angleCount = 0;
    }
  }

  // Deuxième boucle pour le front descendant
  for (int i = 0; i < numPeriods; ++i) {

    // Calcul des angles pour le front descendant
    float angle_phase1_fall = (static_cast<float>(periods_Hall1_fall[i]) / periods_Phase1_fall[i]) * 360;
    float angle_phase2_fall = (static_cast<float>(periods_Hall2_fall[i]) / periods_Phase2_fall[i]) * 360;
    float angle_phase3_fall = (static_cast<float>(periods_Hall3_fall[i]) / periods_Phase3_fall[i]) * 360;

    angle_phase1_fall = angle_phase1_fall >= 180 ? angle_phase1_fall - 360 : angle_phase1_fall;
    angle_phase2_fall = angle_phase2_fall >= 180 ? angle_phase2_fall - 360 : angle_phase2_fall;
    angle_phase3_fall = angle_phase3_fall >= 180 ? angle_phase3_fall - 360 : angle_phase3_fall;

    // Compute absolute values for averaging
    float abs_angle_phase1_fall = abs(angle_phase1_fall);
    float abs_angle_phase2_fall = abs(angle_phase2_fall);
    float abs_angle_phase3_fall = abs(angle_phase3_fall);

    // Mise à jour des valeurs minimales et maximales pour chaque angle
    if (angleCount_fall == 0) {
      minValue1_fall = maxValue1_fall = angle_phase1_fall;
      minValue2_fall = maxValue2_fall = angle_phase2_fall;
      minValue3_fall = maxValue3_fall = angle_phase3_fall;
    } else {
      minValue1_fall = min(minValue1_fall, angle_phase1_fall);
      maxValue1_fall = max(maxValue1_fall, angle_phase1_fall);
      minValue2_fall = min(minValue2_fall, angle_phase2_fall);
      maxValue2_fall = max(maxValue2_fall, angle_phase2_fall);
      minValue3_fall = min(minValue3_fall, angle_phase3_fall);
      maxValue3_fall = max(maxValue3_fall, angle_phase3_fall);
    }

    // Ajouter l'angle à la somme et incrémenter le compteur d'angles
    sumAngles_fall += abs_angle_phase1_fall + abs_angle_phase2_fall + abs_angle_phase3_fall;
    angleCount_fall++;

    if (angleCount_fall == numPeriods) {
    GD.cmd_text(10, y, 28, 0, "____Front_Descendant____");
    y += 30;
      // Calculer la moyenne des angles en utilisant les valeurs absolues
      float moyenneAngle_fall = sumAngles_fall / (3 * numPeriods);  // Il y a 3 angles par période

      GD.cmd_text(10, y, 28, 0, "Moyenne des angles : ");
      GD.cmd_text(x, y, 28, 0, String(moyenneAngle_fall).c_str());
      y += 30;

      GD.cmd_text(10, y, 28, 0, "Valeur minimale pour Hall1-Phase1 : ");
      GD.cmd_text(x, y, 28, 0, String(minValue1_fall).c_str());
      y += 30;

      GD.cmd_text(10, y, 28, 0, "Valeur maximale pour Hall1-Phase1 : ");
      GD.cmd_text(x, y, 28, 0, String(maxValue1_fall).c_str());
      y += 30;

      GD.cmd_text(10, y, 28, 0, "Valeur minimale pour Hall2-Phase2 : ");
      GD.cmd_text(x, y, 28, 0, String(minValue2_fall).c_str());
      y += 30;

      GD.cmd_text(10, y, 28, 0, "Valeur maximale pour Hall2-Phase2 : ");
      GD.cmd_text(x, y, 28, 0, String(maxValue2_fall).c_str());
      y += 30;

      GD.cmd_text(10, y, 28, 0, "Valeur minimale pour Hall3-Phase3 : ");
      GD.cmd_text(x, y, 28, 0, String(minValue3_fall).c_str());
      y += 30;

      GD.cmd_text(10, y, 28, 0, "Valeur maximale pour Hall3-Phase3 : ");
      GD.cmd_text(x, y, 28, 0, String(maxValue3_fall).c_str());
      y += 30;

      // Réinitialiser la somme et le compteur
      sumAngles_fall = 0;
      angleCount_fall = 0;
    }
  }

   // Dessiner le bouton
  GD.ColorRGB(0x00FF00);  // Couleur verte pour le bouton
  GD.Begin(RECTS);
  GD.Vertex2f(BUTTON_X * 16, BUTTON_Y * 16);  // Multiplication par 16 pour la précision
  GD.Vertex2f((BUTTON_X + BUTTON_W) * 16, (BUTTON_Y + BUTTON_H) * 16);
  GD.End();

  GD.ColorRGB(0x000000);  // Couleur du texte
  GD.cmd_text(BUTTON_X + BUTTON_W / 2, BUTTON_Y + BUTTON_H / 2, 31, OPT_CENTER, "Reset");

  GD.swap();  // Afficher tout sur l'écran
}

lesept · March 11, 2025, 9:25am

flafvien:

void resetMicrocontroller() { // Fonction pour simuler un reset du microcontrôleur
  __disable_irq(); // Désactiver les interruptions
  NVIC_SystemReset(); // Effectuer le reset du système
}

Tu ne mets jamais de _enable_irq() donc ça peut poser un problème pour les interruptions ultérieures.

Sinon, tes routines d'interruptions me semblent trop longues. Tu devrais juste y conserver la mise à jour d'un flag et faire les autres traitements hors de la routine.

flafvien · March 25, 2025, 7:10am

Bonjour,

J'ai modifié mon code pour essayer d'obtenir de meilleurs résultats et éviter des problèmes d'acquisition, mais il me reste un souci que je ne sais pas comment le résoudre.

Lorsque je réalise l'acquisition des périodes de mes phases, j'observe que, de temps en temps, la période est soit inférieure, soit supérieure à la valeur attendue. Je sais que la période varie en fonction de la vitesse à laquelle mon moteur tourne, mais le problème persiste de manière irrégulière.

En ce qui concerne l'acquisition des cellules de Hall, lorsque je me mets en mode débogage, je n'ai aucun problème avec les périodes, mais j'en rencontre un avec les phases.

Voir ci-dessous.

Schéma électrique de ma mise en signaux

#include <SPI.h>
#include <GD2.h>

#define SCREEN_WIDTH  800
#define SCREEN_HEIGHT 480

// Seuils de periode
const int Pmax = 500000, Pmin = 10000;

// Broches des signaux
const int phasePins[] = {13, 12, 7};
const int hallPins[] = {2, 6, 8};
const int phasePinsFall[] = {9, 3, 0};
const int hallPinsFall[] = {15, 1, 11};
const int SS_PIN = 10;
const int x = 380;

// Périodes et index
static int periodIndex_Phase[3] = {0}, periodIndex_Hall[3] = {0};
static int periodIndex_Phase_fall[3] = {0}, periodIndex_Hall_fall[3] = {0};

int numStored_Phase[3] = {0}, numStored_Hall[3] = {0};
int numStored_Phase_fall[3] = {0}, numStored_Hall_fall[3] = {0};

volatile unsigned long period_Phase[3] = {0}, period_Hall[3] = {0};
volatile unsigned long period_Phase_fall[3] = {0}, period_Hall_fall[3] = {0};

// Temps des impulsions
volatile unsigned long startTime_Phase[3] = {0}, stopTime_Phase[3] = {0};
volatile unsigned long startTime_Hall[3] = {0}, stopTime_Hall[3] = {0};
volatile unsigned long startTime_Phase_fall[3] = {0}, stopTime_Phase_fall[3] = {0};
volatile unsigned long startTime_Hall_fall[3] = {0}, stopTime_Hall_fall[3] = {0};

// Détection des impulsions
volatile bool phase_detected[3] = {false}, hall_detected[3] = {false};
volatile bool phase_detected_fall[3] = {false}, hall_detected_fall[3] = {false};

// Anti-rebond
const unsigned long debounceDelay = 1000;
volatile unsigned long lastInterruptTime_Phase[3] = {0};
volatile unsigned long lastInterruptTime_Phase_fall[3] = {0};

// Valeurs minimales et maximales
float minValue[3], maxValue[3];
float minValue_fall[3], maxValue_fall[3];

// Somme des angles et compteur
float sumAngles = 0, sumAngles_fall = 0;
int angleCount = 0, angleCount_fall = 0;
const int numPeriods = 12;

// Tableaux des périodes
float periods_Hall[3][numPeriods], periods_Phase[3][numPeriods];
float periods_Hall_fall[3][numPeriods], periods_Phase_fall[3][numPeriods];

void countPulse_Hall_rise_0() { countPulse_Hall_rise(0); }
void countPulse_Hall_rise_1() { countPulse_Hall_rise(1); }
void countPulse_Hall_rise_2() { countPulse_Hall_rise(2); }

void countPulse_Phase_rise_0() { countPulse_Phase_rise(0); }
void countPulse_Phase_rise_1() { countPulse_Phase_rise(1); }
void countPulse_Phase_rise_2() { countPulse_Phase_rise(2); }

void countPulse_Hall_fall_0() { countPulse_Hall_fall(0); }
void countPulse_Hall_fall_1() { countPulse_Hall_fall(1); }
void countPulse_Hall_fall_2() { countPulse_Hall_fall(2); }

void countPulse_Phase_fall_0() { countPulse_Phase_fall(0); }
void countPulse_Phase_fall_1() { countPulse_Phase_fall(1); }
void countPulse_Phase_fall_2() { countPulse_Phase_fall(2); }

void setup() {
  GD.begin();  // Initialisation de l'écran

  for (int i = 0; i < 3; i++) {
    pinMode(phasePins[i], INPUT);
    pinMode(hallPins[i], INPUT);
    pinMode(phasePinsFall[i], INPUT);
    pinMode(hallPinsFall[i], INPUT);
  }

  // Initialisation des valeurs min/max
  for (int i = 0; i < 3; i++) {
    minValue[i] = minValue_fall[i] = 360.0;
    maxValue[i] = maxValue_fall[i] = -360.0;
  }

  angleCount = angleCount_fall = 0;
  sumAngles = sumAngles_fall = 0.0;

  // Démarrage de la communication série
  Serial.begin(115200);

attachInterrupt(digitalPinToInterrupt(phasePins[0]), countPulse_Phase_rise_0, RISING);
attachInterrupt(digitalPinToInterrupt(phasePins[1]), countPulse_Phase_rise_1, RISING);
attachInterrupt(digitalPinToInterrupt(phasePins[2]), countPulse_Phase_rise_2, RISING);
attachInterrupt(digitalPinToInterrupt(hallPins[0]), countPulse_Hall_rise_0, RISING);
attachInterrupt(digitalPinToInterrupt(hallPins[1]), countPulse_Hall_rise_1, RISING);
attachInterrupt(digitalPinToInterrupt(hallPins[2]), countPulse_Hall_rise_2, RISING);

attachInterrupt(digitalPinToInterrupt(phasePinsFall[0]), countPulse_Phase_fall_0, FALLING);
attachInterrupt(digitalPinToInterrupt(phasePinsFall[1]), countPulse_Phase_fall_1, FALLING);
attachInterrupt(digitalPinToInterrupt(phasePinsFall[2]), countPulse_Phase_fall_2, FALLING);
attachInterrupt(digitalPinToInterrupt(hallPinsFall[0]), countPulse_Hall_fall_0, FALLING);
attachInterrupt(digitalPinToInterrupt(hallPinsFall[1]), countPulse_Hall_fall_1, FALLING);
attachInterrupt(digitalPinToInterrupt(hallPinsFall[2]), countPulse_Hall_fall_2, FALLING);

  Serial.println("Programme initialisé");
  __enable_irq();
}

void loop() {

  if (numStored_Hall[0] == numPeriods && numStored_Hall[1] == numPeriods && numStored_Hall[2] == numPeriods && numStored_Phase[0] == numPeriods && numStored_Phase[1] == numPeriods && numStored_Phase[2] == numPeriods && numStored_Hall_fall[0] == numPeriods && numStored_Hall_fall[1] == numPeriods && numStored_Hall_fall[2] == numPeriods && numStored_Phase_fall[0] == numPeriods && numStored_Phase_fall[1] == numPeriods && numStored_Phase_fall[2] == numPeriods) {
    calculateAngle();
    // Réinitialiser les tableaux après avoir calculé les angles
    for (int i = 0; i < 3; i++) {
      numStored_Hall[i] = 0;
      memset(periods_Hall[i], 0, sizeof(periods_Hall[i]));
      numStored_Phase[i] = 0;
      memset(periods_Phase[i], 0, sizeof(periods_Phase[i]));
      numStored_Hall_fall[i] = 0;
      memset(periods_Hall_fall[i], 0, sizeof(periods_Hall_fall[i]));
      numStored_Phase_fall[i] = 0;
      memset(periods_Phase_fall[i], 0, sizeof(periods_Phase_fall[i]));
     
    }
  }
}

void countPulse_Hall_rise(int phaseIndex) {
  if (!hall_detected[phaseIndex] && phase_detected[phaseIndex]) {
    stopTime_Hall[phaseIndex] = micros();
    period_Hall[phaseIndex] = stopTime_Hall[phaseIndex] - startTime_Hall[phaseIndex];
    hall_detected[phaseIndex] = true;

    if (period_Hall[phaseIndex] >= 10) {
      periods_Hall[phaseIndex][periodIndex_Hall[phaseIndex]] = period_Hall[phaseIndex];
      periodIndex_Hall[phaseIndex] = (periodIndex_Hall[phaseIndex] + 1) % numPeriods;
      
      if (numStored_Hall[phaseIndex] < numPeriods) {
        numStored_Hall[phaseIndex]++;
      }
    }
  } else {
    hall_detected[phaseIndex] = false;
  }
}

void countPulse_Phase_rise(int phaseIndex) {
  unsigned long currentTime = micros();
  if (currentTime - lastInterruptTime_Phase[phaseIndex] > debounceDelay) {
    lastInterruptTime_Phase[phaseIndex] = currentTime;

    if (!phase_detected[phaseIndex] && !hall_detected[phaseIndex]) {
      startTime_Phase[phaseIndex] = micros();
      startTime_Hall[phaseIndex] = micros();
      phase_detected[phaseIndex] = true;
    } else {
      stopTime_Phase[phaseIndex] = micros();
      period_Phase[phaseIndex] = stopTime_Phase[phaseIndex] - startTime_Phase[phaseIndex];
      phase_detected[phaseIndex] = false;

      if (period_Phase[phaseIndex] >= Pmin && period_Phase[phaseIndex] <= Pmax) {
        periods_Phase[phaseIndex][periodIndex_Phase[phaseIndex]] = period_Phase[phaseIndex];
        periodIndex_Phase[phaseIndex] = (periodIndex_Phase[phaseIndex] + 1) % numPeriods;

        if (numStored_Phase[phaseIndex] < numPeriods) {
          numStored_Phase[phaseIndex]++;
        }
      }
    }
  }
}

void countPulse_Hall_fall(int hallIndex) {
  if (!hall_detected_fall[hallIndex] && phase_detected_fall[hallIndex]) {
    stopTime_Hall_fall[hallIndex] = micros();
    period_Hall_fall[hallIndex] = stopTime_Hall_fall[hallIndex] - startTime_Hall_fall[hallIndex];
    hall_detected_fall[hallIndex] = true;

    if (period_Hall_fall[hallIndex] >= 10) {
      periods_Hall_fall[hallIndex][periodIndex_Hall_fall[hallIndex]] = period_Hall_fall[hallIndex];
      periodIndex_Hall_fall[hallIndex] = (periodIndex_Hall_fall[hallIndex] + 1) % numPeriods;

      if (numStored_Hall_fall[hallIndex] < numPeriods) {
        numStored_Hall_fall[hallIndex]++;
      }
    }
  } else {
    hall_detected_fall[hallIndex] = false;
  }
}

void countPulse_Phase_fall(int phaseIndex) {
  unsigned long currentTime = micros();
  if (currentTime - lastInterruptTime_Phase_fall[phaseIndex] > debounceDelay) {
    lastInterruptTime_Phase_fall[phaseIndex] = currentTime;

    if (!phase_detected_fall[phaseIndex] && !hall_detected_fall[phaseIndex]) {
      startTime_Phase_fall[phaseIndex] = micros();
      startTime_Hall_fall[phaseIndex] = micros();
      phase_detected_fall[phaseIndex] = true;
    } else {
      stopTime_Phase_fall[phaseIndex] = micros();
      period_Phase_fall[phaseIndex] = stopTime_Phase_fall[phaseIndex] - startTime_Phase_fall[phaseIndex];
      phase_detected_fall[phaseIndex] = false;

      if (period_Phase_fall[phaseIndex] >= Pmin && period_Phase_fall[phaseIndex] <= Pmax) {
        periods_Phase_fall[phaseIndex][periodIndex_Phase_fall[phaseIndex]] = period_Phase_fall[phaseIndex];
        periodIndex_Phase_fall[phaseIndex] = (periodIndex_Phase_fall[phaseIndex] + 1) % numPeriods;

        if (numStored_Phase_fall[phaseIndex] < numPeriods) {
          numStored_Phase_fall[phaseIndex]++;
        }
      }
    }
  }
}

void calculateAngle() {
  __disable_irq();
  GD.ClearColorRGB(0x000000);
  GD.Clear();
  int y = 10;  // Position de départ sur l'écran pour l'affichage

  for (int i = 0; i < numPeriods; ++i) {

    // Calcul des angles pour le front montant
    float angle_phase1 = (static_cast<float>(periods_Hall[0][i]) / periods_Phase[0][i]) * 360;
    float angle_phase2 = (static_cast<float>(periods_Hall[1][i]) / periods_Phase[1][i]) * 360;
    float angle_phase3 = (static_cast<float>(periods_Hall[2][i]) / periods_Phase[2][i]) * 360;

    angle_phase1 = angle_phase1 >= 180 ? angle_phase1 - 360 : angle_phase1;
    angle_phase2 = angle_phase2 >= 180 ? angle_phase2 - 360 : angle_phase2;
    angle_phase3 = angle_phase3 >= 180 ? angle_phase3 - 360 : angle_phase3;

    // Compute absolute values for averaging
    float abs_angle_phase1 = abs(angle_phase1);
    float abs_angle_phase2 = abs(angle_phase2);
    float abs_angle_phase3 = abs(angle_phase3);

    // Mise à jour des valeurs minimales et maximales pour chaque angle
    if (angleCount == 0) {
      minValue[0] = maxValue[0] = angle_phase1;
      minValue[1] = maxValue[1] = angle_phase2;
      minValue[2] = maxValue[2] = angle_phase3;
    } else {
      minValue[0] = min(minValue[0], angle_phase1);
      maxValue[0] = max(maxValue[0], angle_phase1);
      minValue[1] = min(minValue[1], angle_phase2);
      maxValue[1] = max(maxValue[1], angle_phase2);
      minValue[2] = min(minValue[2], angle_phase3);
      maxValue[2] = max(maxValue[2], angle_phase3);
    }

    // Ajouter l'angle à la somme et incrémenter le compteur d'angles
    sumAngles += abs_angle_phase1 + abs_angle_phase2 + abs_angle_phase3;
    angleCount++;

    if (angleCount == numPeriods) {
    GD.cmd_text(10, y, 28, 0, "_____Front_Montant_____");
    y += 30;
      // Calculer la moyenne des angles en utilisant les valeurs absolues
      float moyenneAngle = sumAngles / (3 * numPeriods);  // Il y a 3 angles par période

      GD.cmd_text(10, y, 28, 0, "Moyenne des angles : ");
      GD.cmd_text(x, y, 28, 0, String(moyenneAngle).c_str());
      y += 30;

      GD.cmd_text(10, y, 28, 0, "Valeur minimale pour Hall1-Phase1 : ");
      GD.cmd_text(x, y, 28, 0, String(minValue[0]).c_str());
      y += 30;

      GD.cmd_text(10, y, 28, 0, "Valeur maximale pour Hall1-Phase1 : ");
      GD.cmd_text(x, y, 28, 0, String(maxValue[0]).c_str());
      y += 30;

      GD.cmd_text(10, y, 28, 0, "Valeur minimale pour Hall2-Phase2 : ");
      GD.cmd_text(x, y, 28, 0, String(minValue[1]).c_str());
      y += 30;

      GD.cmd_text(10, y, 28, 0, "Valeur maximale pour Hall2-Phase2 : ");
      GD.cmd_text(x, y, 28, 0, String(maxValue[1]).c_str());
      y += 30;

      GD.cmd_text(10, y, 28, 0, "Valeur minimale pour Hall3-Phase3 : ");
      GD.cmd_text(x, y, 28, 0, String(minValue[2]).c_str());
      y += 30;

      GD.cmd_text(10, y, 28, 0, "Valeur maximale pour Hall3-Phase3 : ");
      GD.cmd_text(x, y, 28, 0, String(maxValue[2]).c_str());
      y += 30;
      
      // Réinitialiser la somme et le compteur
      sumAngles = 0;
      angleCount = 0;
    }
  }

  // Deuxième boucle pour le front descendant
  for (int i = 0; i < numPeriods; ++i) {

    // Calcul des angles pour le front descendant
    float angle_phase1_fall = (static_cast<float>(periods_Hall_fall[0][i]) / periods_Phase_fall[0][i]) * 360;
    float angle_phase2_fall = (static_cast<float>(periods_Hall_fall[1][i]) / periods_Phase_fall[1][i]) * 360;
    float angle_phase3_fall = (static_cast<float>(periods_Hall_fall[2][i]) / periods_Phase_fall[2][i]) * 360;

    angle_phase1_fall = angle_phase1_fall >= 180 ? angle_phase1_fall - 360 : angle_phase1_fall;
    angle_phase2_fall = angle_phase2_fall >= 180 ? angle_phase2_fall - 360 : angle_phase2_fall;
    angle_phase3_fall = angle_phase3_fall >= 180 ? angle_phase3_fall - 360 : angle_phase3_fall;

    // Compute absolute values for averaging
    float abs_angle_phase1_fall = abs(angle_phase1_fall);
    float abs_angle_phase2_fall = abs(angle_phase2_fall);
    float abs_angle_phase3_fall = abs(angle_phase3_fall);

    // Mise à jour des valeurs minimales et maximales pour chaque angle
    if (angleCount_fall == 0) {
      minValue_fall[0] = maxValue_fall[0] = angle_phase1_fall;
      minValue_fall[1] = maxValue_fall[1] = angle_phase2_fall;
      minValue_fall[2] = maxValue_fall[2] = angle_phase3_fall;
    } else {
      minValue_fall[0] = min(minValue_fall[0], angle_phase1_fall);
      maxValue_fall[0] = max(maxValue_fall[0], angle_phase1_fall);
      minValue_fall[1] = min(minValue_fall[1], angle_phase2_fall);
      maxValue_fall[1] = max(maxValue_fall[1], angle_phase2_fall);
      minValue_fall[2] = min(minValue_fall[2], angle_phase3_fall);
      maxValue_fall[2] = max(maxValue_fall[2], angle_phase3_fall);
    }

    // Ajouter l'angle à la somme et incrémenter le compteur d'angles
    sumAngles_fall += abs_angle_phase1_fall + abs_angle_phase2_fall + abs_angle_phase3_fall;
    angleCount_fall++;

    if (angleCount_fall == numPeriods) {
    GD.cmd_text(10, y, 28, 0, "____Front_Descendant____");
    y += 30;
      // Calculer la moyenne des angles en utilisant les valeurs absolues
      float moyenneAngle_fall = sumAngles_fall / (3 * numPeriods);  // Il y a 3 angles par période

      GD.cmd_text(10, y, 28, 0, "Moyenne des angles : ");
      GD.cmd_text(x, y, 28, 0, String(moyenneAngle_fall).c_str());
      y += 30;

      GD.cmd_text(10, y, 28, 0, "Valeur minimale pour Hall1-Phase1 : ");
      GD.cmd_text(x, y, 28, 0, String(minValue_fall[0]).c_str());
      y += 30;

      GD.cmd_text(10, y, 28, 0, "Valeur maximale pour Hall1-Phase1 : ");
      GD.cmd_text(x, y, 28, 0, String(maxValue_fall[0]).c_str());
      y += 30;

      GD.cmd_text(10, y, 28, 0, "Valeur minimale pour Hall2-Phase2 : ");
      GD.cmd_text(x, y, 28, 0, String(minValue_fall[1]).c_str());
      y += 30;

      GD.cmd_text(10, y, 28, 0, "Valeur maximale pour Hall2-Phase2 : ");
      GD.cmd_text(x, y, 28, 0, String(maxValue_fall[1]).c_str());
      y += 30;

      GD.cmd_text(10, y, 28, 0, "Valeur minimale pour Hall3-Phase3 : ");
      GD.cmd_text(x, y, 28, 0, String(minValue_fall[2]).c_str());
      y += 30;

      GD.cmd_text(10, y, 28, 0, "Valeur maximale pour Hall3-Phase3 : ");
      GD.cmd_text(x, y, 28, 0, String(maxValue_fall[2]).c_str());
      y += 30;

      // Réinitialiser la somme et le compteur
      sumAngles_fall = 0;
      angleCount_fall = 0;
    }
  }
  GD.swap();  // Afficher tout sur l'écran
  __enable_irq();
}

system · September 21, 2025, 7:10am

This topic was automatically closed 180 days after the last reply. New replies are no longer allowed.

Topic		Replies	Views
Interruption problem Programming	9	90	September 22, 2025
Multiple interrupt to get hall cell and fcem problem Programming	5	123	August 20, 2024
Arduino uno - verification programme => mesure angle Français	48	5624	May 6, 2021
Arduino - probleme interruptions multiples Français	28	4008	May 6, 2021
deux capteurs Hall simultanément Français	25	3424	May 6, 2021

Interruption problèmes

Related topics