ESP32 Reboot lors de la reception d une commande

Bonjour on ne parvient pas a solutionner un probleme depuis plusieurs semaine notre esp reboot lors de la reception d une commande :confused: avais vous une piste ?
fichier dispo en bas de la page :slight_smile:
voici les commande merci beaucoup pour votre temps

/* commandes CMD /
/
RESET()

  • RESTART()
  • NAME(xxxx) // board_name
  • SSID(xxxxxxxx) // wifi ssid max 16 bits
  • PSWD(xxxxxxxx) // wifi pswd max 32 bits
  • TEMP(;;;;:wink: // config fan TEMP(tempMini, tempMaxi, tempCritique, pwmMini, pwmMaxi, startMini)
    */

esp32_eeprom

FOR/* LIBRAIRIES */
#include "EEPROM.h"
#include "GLOBALS.h"
#include "ROM.h"
#include "WEB.h"
#include "FAN.h"
#include "SYS.h"
#include "COM.h"
#include "Wire.h"
#include "PCA.h"
#include "LM75.h"

void setup() {
  Wire.begin();
  Serial.begin(115200);
    
  if (!EEPROM.begin(4096)) {
    Serial.println("> INIT EEPROM :: ECHEC");
    while(1);
  } else {
    Serial.println("> INIT EEPROM :: OK");
  }
  
  print(true, true, (String)"> PAD NAME :: " + eeReadStr(boardName), true);
  FAN.begin(FAN_PWM);
  loadCredentials();
  DRV.begin();
  print(true, true, (DRV.isPresent() ? F("> DRIVER ... OK") : F("> DRIVER ... ABSENT")), true);
  pinMode(OE_PIN, OUTPUT);
  digitalWrite(OE_PIN, LOW);
  LM75.begin();
  print(true, true, (LM75.isPresent() ? F("> SONDE TEMP ... OK") : F("> SONDE TEMP ... ABSENT")), true);
  delay(1000);
  set_1Hz_interruptTimer();
}

void loop() {

  TIMER_ROUTINE();
  
  CHECK_SERIAL_DATAS();
  
  if(COM.serialIndex){
    COMMAND_EXECUTE();
  }
  
  LM75.GET_TEMP();
  FAN.enable = true;
  DRV.setPin(4, (FAN.enable == true ? 4095 : 0));
  digitalWrite(OE_PIN, (FAN.enable == true ? HIGH : LOW));
  FAN.GESTION_TEMPERATURE();
}

COM.h

#ifndef COM_H_
#define COM_H_

#define MAX_BYTES 128

struct COM{
  String data;
  String cmd;
  byte serialIndex;
  char inputBuffer[MAX_BYTES];
  long Data[32];
} COM;

void CHECK_SERIAL_DATAS() {
  /*while (SerialBT.available() > 0) {  
    char c = SerialBT.eeRead();
    if(c == '\n') {
      return;
    } else {
      COM.inputBuffer[COM.serialIndex] = c;
      ++COM.serialIndex;
    }
  }*/
  
  while (Serial.available() > 0) {  
    char c = Serial.read();
    if(c == '\n') {
      return;
    } else {
      COM.inputBuffer[COM.serialIndex] = c;
      ++COM.serialIndex;
    }
  } 
}

int COMPUTE_CMD(){
  for(int comp = 0; comp < MAX_COMMANDES; ++comp){
    if(COM.cmd.equals(command[comp])) return (comp+1);
  } return 0;
}

String extractData(){
  String tmp = "";
  
  for(int i = 0; i < COM.serialIndex; i++){
    if(COM.inputBuffer[i] == '(') TRUE = true;
    if(COM.inputBuffer[i] == ')') TRUE = false;
    if(TRUE && COM.inputBuffer[i] != '(') tmp += COM.inputBuffer[i];
  } return tmp;
}

void COMMAND_EXECUTE(){
  
  print(true, false, ((String) "\n> RECU: " + COM.inputBuffer + "\n> LONGUEUR_TRAME: " + COM.serialIndex + " bits") , true);
  
  bool end = false;
  int tmp = 0, splitIdx = 0;
  
  for(int idx = 0; idx < COM.serialIndex; ++idx){
    /* split commande */
    if(COM.inputBuffer[idx] != '(' && !end) {
      COM.cmd += COM.inputBuffer[idx];
    } else if(COM.inputBuffer[idx] == '(' && !end) {
      //COM.cmd += '\0';
      end = true;
    }
    /* split datas */
    if(COM.inputBuffer[idx] >= '0' && COM.inputBuffer[idx] <= '9') {
      if(tmp > 0) tmp *= 10;
      tmp += COM.inputBuffer[idx] - '0';
    } 
    if(COM.inputBuffer[idx] == ';' || COM.inputBuffer[idx] == ')' || COM.inputBuffer[idx] == ':' || COM.inputBuffer[idx] == '/'){
      COM.Data[splitIdx] = tmp;
      tmp = 0;
      ++splitIdx;
    }
  }
  
  print(true, false, ((String) "> CMD = " + COM.cmd + "  INDEX_CMD: " + COMPUTE_CMD()), true);
              
  switch(COMPUTE_CMD()){
  default:
    print(true, true, "\t> COMMANDE NON RECONNUE\n", true);
    break;

  case 0:
    print(true, true, "\t> COMMANDE NON RECONNUE\n", true);
    break;

/* SYTEME */

  case 1: //RESTART()
    print(true, true, F("\t> REDEMARRAGE EN COURS ... \n"), true);
    delay(2000);
    ESP.restart();
    break;

  case 2: //RESET()
    FAN.LOAD_SETTINGS(true);
    loadCredentials(true);
    break;

  case 3: //NAME(ESP32_TEST)
    BOARD= extractData();
    eeWriteStr(boardName, BOARD);
    eeWrite(sysSetting, CHECK_OK, BYTE);
    print(true, true, "\t> SAUVEGARDE NOM PAD :: OK" , true);
    break;

  case 4: //SSID(Livebox-b944)
    SSID= extractData();
    eeWriteStr(ssid, SSID);
    eeWrite(sysSetting, CHECK_OK, BYTE);
    print(true, true, "\t> SAUVEGARDE SSID :: OK" , true);
    break;

  case 5: //PSWD(A583E31D223286914BA06BF808)
    PSWD = extractData();
    eeWriteStr(pswd, PSWD);
    eeWrite(sysSetting, CHECK_OK, BYTE);
    print(true, true, "\t> SAUVEGARDE PSWD :: OK" , true);
    break;

  case 6: //TEMP(20;45;50;50;10;90) //TEMP(20;50;60;50;10;90)
    for(int ee = 0; ee < 6; ee++){
      eeWrite(tempMin+ee, COM.Data[ee], BYTE);
    }
    eeWrite(fanSetting, CHECK_OK, BYTE);
    FAN.LOAD_SETTINGS();
    Serial.printf("> FAN_CONFIG(%d;%d;%d;%d;%d;%d)\n", tempMini, tempMaxi, tempCritique,  pwmMini, pwmMaxi, startMini);
    break;
  }
  memset(&COM, '\0', sizeof(COM));
}

#endif

FAN.h

#ifndef FAN_H_
#define FAN_H_

/* interrupt routine fan rpm */
void rpm_fan(){
  ++rpmcount;
}

class FAN {
  public:
    void begin(int enablePin);
    bool LOAD_SETTINGS(bool reset = false);
    void GESTION_TEMPERATURE();
    bool enable;
    int PWM;
  private:
    void analogWrite(int pwm);
    int computePwm();
    int _enablePin;
    bool kickStart;
    unsigned long elapsed;
    int pwm;
    int _pwm;
    int rpm;
};

void FAN::begin(int enablePin){
  _enablePin = enablePin;
  ledcSetup(0, 25000, 12);
  ledcAttachPin(_enablePin, 0);
  /* PWM FAN à 0 */
  ledcWrite(0, 0);
  LOAD_SETTINGS();
  attachInterrupt(digitalPinToInterrupt(FAN_TACH), rpm_fan, FALLING);//interrupt on pin 19
}

bool  FAN::LOAD_SETTINGS(bool reset){
  
  tempMini = 20;
  tempMaxi = 40;
  tempCritique = 45;
  pwmMini  = 10;
  pwmMaxi  = 80;
  startMini= 50;
  
  if(eeRead(fanSetting) && !reset){
    tempMini = eeRead(tempMin);
    tempMaxi = eeRead(tempMax);
    tempCritique = eeRead(tempCrit);
    pwmMini  = eeRead(pwmMin);
    pwmMaxi  = eeRead(pwmMax);
    startMini= eeRead(startMin);
    Serial.println(F("> CHGT CONFIG FAN :: OK"));
  } 
  
  if(reset){
    eeWrite(tempMin, tempMini);
    eeWrite(tempMax, tempMaxi);
    eeWrite(tempCrit, tempCritique);
    eeWrite(pwmMin, pwmMini);
    eeWrite(pwmMax, pwmMaxi);
    eeWrite(startMin, startMini);
    eeWrite(fanSetting, CHECK_OK);
    Serial.println(F("> RESET FAN :: OK"));
  }
}

int FAN::computePwm(){
  if(temperature < tempMini){
    return 0;
  } else if(temperature >= tempMini && temperature < tempMaxi){
    return(map(((int)temperature*100), ((int)tempMini*100), ((int)tempMaxi*100), ((int)(4095*pwmMini)/100.00), ((int)(4095*pwmMaxi)/100.00)));
  } else if(temperature >= tempMaxi){
    return((int)(4095/100.00)*pwmMaxi);
  } 
}

void FAN::analogWrite(int pwm){
  ledcWrite(0, pwm);
}

void FAN::GESTION_TEMPERATURE(){
  if(enable == false) {
    kickStart = false;
    analogWrite(0);
    return;
  } else if(enable == true) {
    if(kickStart == false){
      analogWrite(((int)(4095/100.00)*pwmMaxi));
      elapsed = millis();
      kickStart = true;
    } else {
      if(kickStart == true && (millis() - elapsed >= 500)){ 
        pwm = computePwm();
        PWM = pwm;
        analogWrite(pwm);
      }
    }
  }
}

#endif
extern FAN FAN;
class  FAN FAN;

GLOBALS.h

#ifndef GLOBALS_H_
#define GLOBALS_H_

/* SYSTEME */
#define CHECK_OK 0x0F
#define debug 1

/* ENTREES/SORTIES */
#define CPU_LED   2
#define FAN_PWM   5
#define FAN_TACH  18
#define OE_PIN    19

void print (bool usb, bool bt, String sentence, bool nl){
  if(usb) {
    (nl == true) ? Serial.println(sentence) : Serial.print(sentence);
  } delay(5);
  /*if(bt) {
    (nl == true) ? SerialBT.println(sentence) : SerialBT.print(sentence);
  } delay(5);*/
}

/* EEPROM ADRESSES */
#define fanSetting  0
#define drvSetting  1
#define drvFreq     2
// RESERVE          3

// CONFIG GESTION TEMPERATURE //
#define tempMin     10
#define tempMax     11
#define tempCrit    12
#define pwmMin      13
#define pwmMax      14
#define startMin    15

// BOARD //
#define sysSetting  512
#define boardName   513
// WIFI CREDENTIALS //
#define ssid        530
#define pswd        560

/* FAN */
float temperature  = 0;
byte tempMini      = 0;
byte tempMaxi      = 0;
byte tempCritique  = 0;
byte pwmMini       = 0;
byte pwmMaxi       = 0;
byte startMini     = 0;
long rpmcount      = 0;
long rpm           = 0;

enum {
  AUCUNE,
  MAXI,
  CRITIQUE,
  DEFECTUEUSE
} ALARME;

/* COM */
#define MAX_COMMANDES 20
String sys = "";
bool TRUE = false;

const String command[MAX_COMMANDES] = {
  "RESTART",
  "RESET",
  "NAME",
  "SSID",
  "PSWD",
  "TEMP"
};

/* WIFI */
bool server_Started = 0;
static String BOARD = "";
static String SSID  = "";
static String PSWD  = "";

#endif

LED.h

#ifndef LED_H_
#define LED_H_



#endif

LM75.h

#ifndef LM75_H_
#define LM75_H_

#define LM75_ADDR     0x48
#define LM75_REGISTER 0

class LM75
{
  public:
          bool isPresent();
          void begin(void);
          void GET_TEMP ();
};

void LM75::begin(){
  if(!Wire.available()) Wire.begin();
}

void LM75::GET_TEMP () {
  float _temp;
  Wire.beginTransmission(LM75_ADDR);
  Wire.write(LM75_REGISTER);  
  Wire.endTransmission();
  Wire.requestFrom(LM75_ADDR, 2);
  word regdata = (Wire.read() << 8) | Wire.read();
  _temp = ((float)(int)regdata / 32.00) / 8.00;
  if((_temp - temperature > 0.4) || (_temp - temperature < 0.4)) temperature = _temp;
}

bool LM75::isPresent() {
  Wire.beginTransmission (LM75_ADDR);
  Wire.write((uint8_t)0x00);
  return (Wire.endTransmission() == 0 ? true : false);
}

boolean temperatureHaute(float temp, byte consigne) {
  return(temp >= consigne ? true : false );
}

boolean temperatureBride(float temp, byte consigne) {
  return(temp >= consigne ? true : false );
}

extern LM75 LM75;
class  LM75 LM75;

#endif

PCA.h

#ifndef PCA_H_
#define PCA_H_

#define PCA9685_SUBADR1 0x2
#define PCA9685_SUBADR2 0x3
#define PCA9685_SUBADR3 0x4

#define PCA9685_MODE1 0x0
#define PCA9685_PRESCALE 0xFE

#define LED0_ON_L 0x6
#define LED0_ON_H 0x7
#define LED0_OFF_L 0x8
#define LED0_OFF_H 0x9

#define ALLLED_ON_L 0xFA
#define ALLLED_ON_H 0xFB
#define ALLLED_OFF_L 0xFC
#define ALLLED_OFF_H 0xFD

/**************************************************************************/
/*! 
    @brief  Class that stores state and functions for interacting with PCA9685 PWM chip
*/
/**************************************************************************/
class Adafruit_PWMServoDriver {
 public:
  Adafruit_PWMServoDriver(uint8_t addr = 0x40);
  Adafruit_PWMServoDriver(TwoWire *I2C, uint8_t addr = 0x40);
  void begin(void);
  void reset(void);
  bool isPresent();
  void setPWMFreq(float freq);
  void setPWM(uint8_t num, uint16_t on, uint16_t off);
  void setPin(uint8_t num, uint16_t val);

 private:
  uint8_t _i2caddr;
  uint8_t read8(uint8_t addr);
  void write8(uint8_t addr, uint8_t d);
};


Adafruit_PWMServoDriver::Adafruit_PWMServoDriver(uint8_t addr) {
  _i2caddr = addr;
}

/**************************************************************************/
/*! 
    @brief  Instantiates a new PCA9685 PWM driver chip with the I2C address on a TwoWire interface
    @param  i2c  A pointer to a 'Wire' compatible object that we'll use to communicate with
    @param  addr The 7-bit I2C address to locate this chip, default is 0x40
*/
/**************************************************************************/
Adafruit_PWMServoDriver::Adafruit_PWMServoDriver(TwoWire *i2c, uint8_t addr) {
  _i2caddr = addr;
}

/**************************************************************************/
/*! 
    @brief  Setups the I2C interface and hardware
*/
/**************************************************************************/
void Adafruit_PWMServoDriver::begin(void) {
  reset();
  // set a default frequency
  setPWMFreq(500);
}


/**************************************************************************/
/*! 
    @brief  Sends a reset command to the PCA9685 chip over I2C
*/
/**************************************************************************/
void Adafruit_PWMServoDriver::reset(void) {
  write8(PCA9685_MODE1, 0x80);
  delay(10);
}

bool Adafruit_PWMServoDriver::isPresent() {
  Wire.beginTransmission (_i2caddr);
  Wire.write((uint8_t)0x00);
  return (Wire.endTransmission() == 0 ? true : false);
}

/**************************************************************************/
/*! 
    @brief  Sets the PWM frequency for the entire chip, up to ~1.6 KHz
    @param  freq Floating point frequency that we will attempt to match
*/
/**************************************************************************/
void Adafruit_PWMServoDriver::setPWMFreq(float freq) {
  freq *= 0.9;  // Correct for overshoot in the frequency setting (see issue #11).
  float prescaleval = 25000000;
  prescaleval /= 4096;
  prescaleval /= freq;
  prescaleval -= 1;
  uint8_t prescale = floor(prescaleval + 0.5);
  uint8_t oldmode = read8(PCA9685_MODE1);
  uint8_t newmode = (oldmode&0x7F) | 0x10; // sleep
  write8(PCA9685_MODE1, newmode); // go to sleep
  write8(PCA9685_PRESCALE, prescale); // set the prescaler
  write8(PCA9685_MODE1, oldmode);
  delay(5);
  write8(PCA9685_MODE1, oldmode | 0xa0);  //  This sets the MODE1 register to turn on auto increment.
  Serial.print("Mode now 0x"); Serial.println(read8(PCA9685_MODE1), HEX);
}

/**************************************************************************/
/*! 
    @brief  Sets the PWM output of one of the PCA9685 pins
    @param  num One of the PWM output pins, from 0 to 15
    @param  on At what point in the 4096-part cycle to turn the PWM output ON
    @param  off At what point in the 4096-part cycle to turn the PWM output OFF
*/
/**************************************************************************/
void Adafruit_PWMServoDriver::setPWM(uint8_t num, uint16_t on, uint16_t off) {
  Wire.beginTransmission(_i2caddr);
  Wire.write(LED0_ON_L+4*num);
  Wire.write(on);
  Wire.write(on>>8);
  Wire.write(off);
  Wire.write(off>>8);
  Wire.endTransmission();
}

/**************************************************************************/
/*! 
    @brief  Helper to set pin PWM output. Sets pin without having to deal with on/off tick placement and properly handles a zero value as completely off and 4095 as completely on.  Optional invert parameter supports inverting the pulse for sinking to ground.
    @param  num One of the PWM output pins, from 0 to 15
    @param  val The number of ticks out of 4096 to be active, should be a value from 0 to 4095 inclusive.
    @param  invert If true, inverts the output, defaults to 'false'
*/
/**************************************************************************/
void Adafruit_PWMServoDriver::setPin(uint8_t num, uint16_t val)
{
  // Clamp value between 0 and 4095 inclusive.
  val = min(val, (uint16_t)4095);
  
  if (val == 4095) {
    // Special value for signal fully on.
    setPWM(num, 4096, 0);
  } else if (val == 0) {
    // Special value for signal fully off.
    setPWM(num, 0, 4096);
  } else {
    setPWM(num, 0, val);
  }
}

/*******************************************************************************************/

uint8_t Adafruit_PWMServoDriver::read8(uint8_t addr) {
  Wire.beginTransmission(_i2caddr);
  Wire.write(addr);
  Wire.endTransmission();
  Wire.requestFrom((uint8_t)_i2caddr, (uint8_t)1);
  return Wire.read();
}

void Adafruit_PWMServoDriver::write8(uint8_t addr, uint8_t d) {
  Wire.beginTransmission(_i2caddr);
  Wire.write(addr);
  Wire.write(d);
  Wire.endTransmission();
}

extern Adafruit_PWMServoDriver DRV;
class  Adafruit_PWMServoDriver DRV;
#endif

ROM.h

#ifndef ROM_H_
#define ROM_H_

enum {
  BYTE,
  INT,
  LONG,
} types;

bool eeWrite(int addr, long data, byte type = BYTE){
  yield();
  switch(type){
    case BYTE: EEPROM.writeByte(addr, (byte)data); break;
    case INT:  EEPROM.writeInt(addr, (int)data); break;
    case LONG: EEPROM.writeLong(addr, data); break;
  } 
  delay(5);
  EEPROM.commit();
  delay(1);
  return true;
}

long eeRead(int addr, byte type = BYTE){
  switch(type){
    case BYTE: return EEPROM.readByte(addr); break;
    case INT:  return EEPROM.readInt(addr); break;
    case LONG: return EEPROM.readLong(addr); break;
  }
}

bool eeWriteStr(int addr, String str){
  yield();
  byte laenge = str.length()+1;
  
  char buff[laenge];
  str.toCharArray(buff, laenge);
  eeWrite(addr, laenge, BYTE);
  
  for(int ee = 0; ee < laenge; ee++){
    eeWrite(addr+1+ee, buff[ee], BYTE);
  }
  return true;
}

String eeReadStr(int addr){
  yield();
  String str = "";
  byte laenge = eeRead(addr, BYTE);

  if(!laenge) return "NC";
      
  for(int ee = 0; ee < laenge; ee++){
    str += (char)eeRead(addr+1+ee, BYTE);
  }
  return str;
}

#endif

SYS.h

#ifndef SYS_H_
#define SYS_H_

volatile int interruptCounter = 0;
hw_timer_t * timer = NULL;
portMUX_TYPE timerMux = portMUX_INITIALIZER_UNLOCKED;

void IRAM_ATTR onTimer() {
  portENTER_CRITICAL_ISR(&timerMux);
  interruptCounter++;
  portEXIT_CRITICAL_ISR(&timerMux);
}

bool set_1Hz_interruptTimer(){
  pinMode(CPU_LED, OUTPUT);
  timer = timerBegin(0, 80, true);
  timerAttachInterrupt(timer, &onTimer, true);
  timerAlarmWrite(timer, 1000000, true);
  timerAlarmEnable(timer);
  return true;
}

unsigned long loopStat = 0;

void TIMER_ROUTINE(bool newTime = false, long time = 0){
  if(newTime) {
    timerAlarmWrite(timer, time, true);
  }
  
  if (interruptCounter > 0) {
    portENTER_CRITICAL(&timerMux);
    interruptCounter--;
    portEXIT_CRITICAL(&timerMux);
    rpm = (rpmcount*30);
    rpmcount = 0;
    if(debug){
      Serial.printf("\n> LOOP STAT: %d\n", loopStat++);
      Serial.printf("> FAN_CONFIG(%d;%d;%d;%d;%d;%d)\n", eeRead(tempMin), eeRead(tempMax), eeRead(tempCrit),  eeRead(pwmMin), eeRead(pwmMax), eeRead(startMin));
      Serial.printf("> FAN_VALUES(%d pwm; %d %c; %d rpm)\n", FAN.PWM, map(FAN.PWM, 0, 4095, 0, 100), (char)37, rpm);
      Serial.printf("> TEMPERATURE: %.2fc\n", temperature);
      //print(true, true, ((String)"> NAME :: " + eeReadStr(boardName)), true);
      //print(true, true, ((String)"> SSID :: " + eeReadStr(ssid)), true);
      //print(true, true, ((String)"> PSWD :: " + eeReadStr(pswd)), true);
    } 
    digitalWrite(CPU_LED, digitalRead(CPU_LED) ^ 1);
  }
}

WEB.h

#ifndef WEB_H_
#define WEB_H_

void  loadCredentials(bool reset = false){

  BOARD = "ESP32_TEST";
  SSID = "nc";
  PSWD = "nc";

  if(reset){
    eeWriteStr(boardName, BOARD);
    eeWriteStr(ssid, SSID);
    eeWriteStr(pswd, PSWD);
    eeWrite(sysSetting, 0, BYTE);
    Serial.println(F("> RESET WIFI :: OK"));
  } else {
    print(true, true, F("\n/* WIFI CONFIGURATION */"), true);
    if(eeRead(sysSetting, BYTE)){
      BOARD = eeReadStr(boardName);
      SSID = eeReadStr(ssid);
      print(true, true, (String)"SSID :: " + SSID, true);
      PSWD = eeReadStr(pswd);
      print(true, true, (String)"PSWD :: " + PSWD + "\n", true);
    } else {
      print(true, true, F("> PAS CONFIGURE"), true);
    }
  }
}

#endif

voici les fichiers

chancelog.h (273 Bytes)

COM.h (3.46 KB)

esp32_eeprom.ino (1.18 KB)

FAN.h (2.37 KB)

GLOBALS.h (1.51 KB)

LED.h (46 Bytes)

LM75.h (1.03 KB)

PCA.h (5.8 KB)

ROM.h (1.14 KB)

SYS.h (1.54 KB)

WEB.h (754 Bytes)

Si tu bloques depuis plusieurs semaines, je pense que tu aurais pu affiner un peu plus le diagnostic.

J'ai pas trop envie de bouffer toutes ces lignes de code mais d√©j√† il y a quelques trucs qui m'ont interpell√©es. Il faut revenir tr√®s r√©guli√®rement dans loop car c'est l√† qu'on rend la main aux t√Ęches de fond li√©es √† la communication WiFi, et autres ..... Donc pas de delay(), pas de boucle while ou for qui bloquent l'ex√©cution pendant plusieurs millisecondes. Si tu bloques l'ex√©cution le watchdog g√©n√®re un reset.

Bonsoir

-pas évident de plonger dans tout ce code !!

-les recomendations de fdufnews ont elles la même force avec l’ESP32 (double coeur) qu’avec l’ESP8266 ?

-si l’ESP32 reboote il doit sans doute dire quelque chose au reboot ? quoi ?

-peut être activer le décodeur de trace d’exceptions , tenter de décrypter son compte redu et au besoin l’envoyer aux spécialistes sur le gitter d’ESP32/Arduino

Bonjour,

Si l'esp32 reboot sans raison (connue), la première chose à faire est de vérifier l'alimentation, ajouter un condensateur sur l'alimentation.

Je pense avoir une piste lorsque je retire mon fils tachymètre du fan j ai plus aucun souci. Donc ma gestion dans le code pour ma mesure rpm de mon fan fais planté mon esp32 si une personne a une piste pour réalisé cette tache sans tous plante gérer dans fan.h merci

@al1fch : l'ESP32 est un simple cŇďur avec un cŇďur suppl√©mentaire d√©di√© √† la COM sans fil, donc pas de multitasking pour les calculs.

Jerem : mets en pratique les recommandations de fdufnews.

Bonsoir,

Dans votre ligne :

attachInterrupt(digitalPinToInterrupt(FAN_TACH), rpm_fan, FALLING);//interrupt on pin 19

il vous faut passer l'adresse de la fonction rpm_fan, soit :

attachInterrupt(digitalPinToInterrupt(FAN_TACH), &rpm_fan, FALLING);//interrupt on pin 19

Bonne bidouille

MicroQuettas

MicroQuettas: Bonsoir, il vous faut passer l'adresse de la fonction rpm_fan, soit :

attachInterrupt(digitalPinToInterrupt(FAN_TACH), &rpm_fan, FALLING);//interrupt on pin 19

Bonne bidouille MicroQuettas

merci pour ce retour malheureusement cela ne fonctionne pas d ailleurs peut tu m explique la différence ?

MicroQuettas: Bonsoir,

Dans votre ligne :

attachInterrupt(digitalPinToInterrupt(FAN_TACH), rpm_fan, FALLING);//interrupt on pin 19

il vous faut passer l'adresse de la fonction rpm_fan, soit :

attachInterrupt(digitalPinToInterrupt(FAN_TACH), &rpm_fan, FALLING);//interrupt on pin 19

Bonne bidouille

MicroQuettas

Non, la première forme est la bonne. Voir ici.

attachInterrupt(digitalPinToInterrupt(FAN_TACH), rpm_fan, FALLING);//interrupt on pin 19

Par contre, il faudrait déclarer rpmcount en volatile car cette variable est modifiée dans la routine d'interruption.

Bonsoir,

Vérification faite https://en.cppreference.com/w/cpp/language/pointer, section

Pointers to functions

A pointer to function can be initialized with an address of a non-member function or a static member function. Because of the function-to-pointer implicit conversion, the address-of operator is optional:

void f(int);
void (*p1)(int) = &f;
void (*p2)(int) = f; // same as &f

c'est pareil car il y a une conversion implicite... Cela explique pourquoi cela marche avec ou sans "&" !

Merci à fdufnews, j'ai appris quelque chose !

Pour votre bug, s'il est systématique et se manifeste rapidement, vous avez de la chance, cela ira plus vite. Il vous faut couper des branches de code (en les mettant en commentaires) pour cerner l'animal. Commencez large, puis une fois que vous avez trouvé une première piste, rapetissez le cercle. Vous allez finir par le débusquer...

Bonne chasse et bonne bidouille,

MicroQuettas