compatibilité et autre avec l'ESP32

[neo888]

Bonjour la communauté!

Je viens vers vous (après avoir bien lu évidemment le coup de gueule de 68tjs! )
Je vais essayer d'être clair dans l'énoncé de mon(mes) problèmes:

Il y a quelques temps, j'ai programmé sur une carte romeo ble de dfrobot un thermostat avec 3 sondes ds18b20, le contrôle d'un moteur pas à pas,... bref un thermostat qui fonctionnait nickel. Pour visualiser le résultat j'utilisais un écran 4 lignes.
Seulement comme j'avais envie de faire évoluer ce projet pour toucher à "plus"et en l'occurence le wifi, j'ai fait l'acquisition d'une wemos ttgo (D1 R32 équivalente à l'espduino32 de chez doit) pour l'utiliser avec une appli que j'ai faite avec app inventor. Je me suis servi aussi de TUNIOT Code pour l'approche "souple" vers le wifi.
Donc pour pouvoir utiliser la wemos, j'ai téléchargé le sdk (espressif-esp32) et effectué l'import dans le dossier :

mes documents/arduino/hardware/espressif/esp32

J'ai utilisé le get.exe fournis dans le répertoire tool ->résultat tout est ok.
Lorsque je lance l'IDE j'ai bien les nouvelles cartes présentes ainsi que les exemples.
De ce que j'ai trouvé comme source, cette carte s'utilise avec le type de carte: ESP32 Dev Mod
Et c'est là qu'arrive les problèmes :

1 - Lorsque je lance l'IDE il me dit dans la console du bas (et sans rien lui demander) que certaines librairies ne sont pas compatibles:

Bibliothèque non valide trouvée dans D:\DOCUMENTS\Arduino\hardware\espressif\esp32\libraries\BLE : D:\DOCUMENTS\Arduino\hardware\espressif\esp32\libraries\BLE

Je n'utilise pas le BLE donc ça n'a pas d'impact (enfin je suppose...)

2 - Je charge mon programme "thermostat" et que je fais une vérification, il me dit:

Plusieurs bibliothèque trouvées pour "WiFi.h"
Utilisé : D:\DOCUMENTS\Arduino\hardware\espressif\esp32\libraries\WiFi
Non utilisé : C:\Program Files (x86)\Arduino\libraries\WiFi
exit status 1
'analogWrite' was not declared in this scope

Je me dit qu'il doit y avoir un problème dans les déclarations pour l'analogwrite. Je ne trouve pas, je bascule le type de carte vers le classique Arduino/Genuino Uno et là tout fonctionne.

J'ai du mal à visualiser la source des problèmes (enfin si, depuis que j'ai installer ce package).
J'imagine: plusieurs lib identiques et donc l'IDE a du mal à aller chercher la bonne.
La librairie ESP32 est indispensable pour utiliser cette carte, est ce que je peux manuellement "faire le ménage" pour éviter les conflits?
Si oui faut-il mieux supprimer ceux fournis avec l'IDE (je parle principalement de WiFi.h)?
Quelqu'un a-t-il déjà utiliser ce type de carte et/ou eu ces problèmes avec la librairie?

J'ai utilisé la wemos avec comme type de carte plusieurs autres nom (lolin32,...) et les résultats sont pires donc je pense que l'association avec l'ESP dev Mod est bonne.

En espérant trouver une solution.
Je vous remercie d'avance pour vos conseils!

Bonne soirée

[Artouste]

neo888:
Bonjour la communauté!

Je viens vers vous (après avoir bien lu évidemment le coup de gueule de 68tjs! )
Je vais essayer d'être clair dans l'énoncé de mon(mes) problèmes:

Bonne et excellente démarche

Mais je ne crois pas avoir lu dans ton énoncé , l'OS (et version) utilisé ,la version de l'IDE arduino utilisée" ? 8)

[al1fch]

Bonjour

Que ce soit sous Linux ou Windos 10 je n'ai pas rencontré de pb analogues en effectuant l'installation comme indiqué sur le github Arduino Core for ESP32.
(IDE Arduino 1.8.5, cartes Wemos Lolin32 et Lolin32 Lite)

Deux remarques:
AnalogWrite n'est pas encore opérationnel
La prise en charge du Bluetooth est 'en progrès', utilser le BLE aujourd'hui sur un ESP32 sous IDE Arduino c'est accepter d' "essuyer les plâtres"

[neo888]

Bonjour à vous, et merci pour vos réponses. J'ai déjà une partie de réponse! ça avance!

Artouste:
Mais je ne crois pas avoir lu dans ton énoncé , l'OS (et version) utilisé ,la version de l'IDE arduino utilisée" ? 8)

et mince... (moi qui pensait mon post parfait!)
Blague mise à part, je tourne sous win10pro64 et l'IDE 1.8.5.

Je pense que si j'avais eu une lolin32, je n'aurais peut-être pas eu le problème vu qu'elle est clairement acceptée comme sa propre carte dans l'IDE. Seulement je tourne en 12v et j'avais besoin du Vin 12v pour un ventilo pwm.

Pour la compatibilité BLE, je vois du coup le rapport avec le message affiché sur la console. Je ne l'utilise pas donc ce n'est pas vraiment un problème. J'avais surtout peur que ce problème de validité de librairie BLE puisse perturber la bonne exécution du programme.

Pour l' AnalogWrite c'est plus embêtant , avez-vous entendu parlé une date possible d'intégration?
Si non, par quoi la remplacer?
Pour bien connaître son cheminement, AnalogWrite est une fonction de wire.h ?

Il y a bien une autre fonction que j'utilise : DigitalWrite pour récupérer les pulsations du ventilateur

digitalWrite(pinPulse, HIGH);

qui, elle, n'a pas l'air de poser de problème.
Apparemment sur les wroom32, tous les pins sont digitaux puisque tous pwm. Du coup puis-je remplacer par celle-ci?

D'ailleurs comment se fait-il qu'il faille utiliser un AnalogWrite pour faire varier la vitesse d'un ventilateur alors que celui-ci est brancher sur un pin digital pwm?
Je crois que je n'ai pas bien saisie la nuance entre ces deux fonctions...

[neo888]

Bonjour, je reviens vers vous.

En faisant quelques de recherches, je suis tomber sur une fonction qui remplacerait analogwrite à savoir:

ledcwrite() où on renseigne le canal et le duty (j'imagine la valeur "pwm")

j'admets ne pas tout comprendre. Il y a :

ledcSetup() où il faut renseigner un canal, une fréquence et une résolution.
ledcAttachPin() où il faut renseigner le port et le canal (0-15)

J'aurais plusieurs questions pour bien comprendre cette fonction et pour pouvoir l'utiliser pour faire varier la vitesse du ventilateur:

1 - Comment définir la fréquence? j'imagine que celle-ci est liée directement avec le pwm mais comment la trouver?
2 - La résolution? 8-10,12 bits? j'ai vu dans l'exemple sur le contrôle du fondu d'une led une résolution de 13bits
3 - Le duty se calcul apparemment comme ceci :
uint32_t duty = (8191 / valueMax) * min(value, valueMax);
Je vois bien valuemax qui est 255 mais min() correspond à quoi?

ça fait beaucoup de paramètre pour la gestion pwm et ça alourdit le code.
En tout cas avec cette fonction, suis-je dans le bon chemin?

merci pour votre aide

[al1fch]

Bonjour

c'est nouveau, ça vient de sortir il y a quelques jours dans la toute dernière version des outils ESP32 pour IDE Arduino; Autre nouveauté notable : sérieBluetooth (BT classique)

il faut donc accepter 'd'essuyer les plâtres' en attendant la doc....

3 exemples sont maintenant fournis dans "ESP32/Analog Out"
tous les 3 mettent en oeuvre le 'sigma delta' et/ou les pwm de la puce ESP32

la fréquence est définie selon les cas en #define ou par l'appel d'une fonction ledcSetup() ou sigmaDeltasetup()
Je joins les 3 nouveaux exemples

Voilà l'information concernant le travail en cours sur AnalogWrite et les alternatives déjà exploitables (source github ESP32 Arduino)

LEDCSoftwareFade.ino (1.6 KB)

ledcWrite_RGB.ino (3.67 KB)

SigmaDelta.ino (385 Bytes)

[neo888]

Effectivement il faut que je mette à jour.

Par contre j'avais bien les exemples analogOut et c'est sur les 2 exemples pour led que j'ai essayer de comprendre.
Mais en fait ce qui peut remplacer l'analogWrite c'est plutôt le sigmaDeltaWrite. Il y a toujours cette question de la fréquence. Dans l'exemple elle est de 312500Hz. pourquoi?
Je vais tester sans changer cette fréquence et voir si le ventilo réagit.

Idem concernant le ledcsetup et l'histoire de la fréquence/résolution. dans l'exemple sur le fade, il est spécifié une fréquence de 5KHz et une résolution de 13bits alors que dans l'exemple rgb elle est de 12Khz et 8 bits.
Comment définir la bonne fréquence et la bonne résolution?
A quoi sert une grosse résolution pour une led? serait-ce juste pour faire le fade?

Merci al1fch la

[lesept]

neo888:
3 - Le duty se calcul apparemment comme ceci :
uint32_t duty = (8191 / valueMax) * min(value, valueMax);
Je vois bien valuemax qui est 255 mais min() correspond à quoi?

Si je comprends bien ta question : min(value, valueMax) renvoie la plus petite valeur des deux arguments value et valueMax ; ça permet de mettre un seuil maximal à la variable value. Ainsi, même si value dépasse la valeur seuil valueMax, la variable duty sera comprise entre 0 et 8191 / valueMax * valueMax donc 8191 (en supposant que value est positif ou nul).

[al1fch]

je n'ai pas encore étudié ces exemples nouveaux et encore moins le hardware ESP32 pour les PWM

je suppose que la fréquence dérive de celle de l'oscillateur 80MHZ par divisions successives (+ parametrage de la chaine de division de fréquence)

je n'utilise pas de leds mais suppose qu'une résolution plus élevée permet de faire un 'dégradé' d'intensités lumineuses beaucoup plus progressif, idem pour l'addition de couleurs

[neo888]

Je viens de faire l'essaie avec ce code :

#define pinFan 16                                                                 
#define pinPulse 17                               
unsigned long pulse;                            
unsigned int RPM = 0;                        


void setup()
{
    Serial.begin(115200);
    //setup channel 0 with frequency 312500 Hz
    sigmaDeltaSetup(0, 312500);
    //attach pin 16 to channel 0
    sigmaDeltaAttachPin(pinFan,0);
    //initialize channel 0 to off
    sigmaDeltaWrite(0, 0);
    pinMode(pinFan, OUTPUT);
    pinMode(pinPulse,INPUT);
    digitalWrite(pinPulse,HIGH);
}

void loop()
{
    //slowly ramp-up the value
    //will overflow at 256
    static uint8_t i = 0;
    sigmaDeltaWrite(0, i++);
    pulse = pulseIn(pinPulse, LOW, 1000000);           
  RPM = (60 / (pulse / 1000000.0))/4;                 
  Serial.println(RPM);
  Serial.println(i);
    delay(100);
}

c'est celui de l'exemple sigmaDelta. j'ai rajouté les déclarations des pins tachimètre et pwm du ventilo et renseigne les valeurs sur le moniteur.
Dites-moi si je n'ai pas fait d'erreurs.
Bon sur le moniteur je vois bien l'incrémentation et la RPM (pas bonne du tout, le calcul doit différé d'un arduino...). D'ailleurs, le défilement s'emballe dès que RPM change, plus la valeur est petite et plus ça va vite.
Arrivé à i=36 le RPM s'emballe (d'ailleurs pour lui 4294967295 veut dire rpm=0

4294967295
35
4294967295
36
600000
37
3750000
38
4294967295
39
4294967295
40
4294967295
41
4294967295
42
4294967295
43
4294967295
44
244
45
600000
46
9196
47
4294967295
48
4294967295
49
1660
50
4294967295
51
4294967295
52
110
53
5868
54
11904

mais le ventilo se declenche vers i=110 directement à fond, sans progression. J'imagine que la fréquence a son rôle...

oui al1fch, je pense à ça aussi. une meilleur résolution et fréquence permet un fondu plus fluide avec le moins de scintillement possible.

lesept , je comprends ce que tu veut dire et du coup 'value' ne dépassera jamais son seuil : 'valuemax'
en fait on calcul duty grâce à value qui est entre 0 et 255 (pour l'amplitude pwm)?

[hazerty565]

/*
  ledcWrite_demo_ESP32.ino
  Runs through the full 255 color spectrum for an rgb led 
  Demonstrate ledcWrite functionality for driving leds with PWM on ESP32
 
  This example code is in the public domain.
 */
 
// Set up the rgb led names
uint8_t ledR = 12;
uint8_t ledG = 14; // internally pulled up
uint8_t ledB = 13; 

uint8_t myLed = 5;  // on-board blue led (also internally pulled up)

uint8_t ledArray[3] = {1, 2, 3}; // three led channels

const boolean invert = false; // set true if common anode, false if common cathode

uint8_t color = 0;          // a value from 0 to 255 representing the hue
uint32_t R, G, B;           // the Red Green and Blue color components
uint8_t brightness = 255;  // 255 is maximum brightness, but can be changed

// the setup routine runs once when you press reset:
void setup() 
{             
  pinMode(myLed, OUTPUT); 
  digitalWrite(myLed, LOW);// Turn off on-board blue led
  
  ledcAttachPin(ledR, 1); // assign RGB led pins to channels
  ledcAttachPin(ledG, 2);
  ledcAttachPin(ledB, 3);
  
  // Initialize channels 
  // channels 0-15, resolution 1-16 bits, freq limits depend on resolution
  // ledcSetup(uint8_t channel, uint32_t freq, uint8_t resolution_bits);
  ledcSetup(1, 12000, 8); // 12 kHz PWM, 8-bit resolution
  ledcSetup(2, 12000, 8);
  ledcSetup(3, 12000, 8);

 for(uint8_t i=0; i < 3; i++) {
  // ledcWrite(channel, dutycycle)
  // For 8-bit resolution duty cycle is 0 - 255
  ledcWrite(ledArray[i], 255);  // test high output of all leds in sequence
  delay(1000);
  ledcWrite(ledArray[i], 0);
 }
 
}

// void loop runs over and over again
void loop() 
{
 for (color = 0; color < 255; color++) { // Slew through the color spectrum

  hueToRGB(color, brightness);  // call function to convert hue to RGB

  // write the RGB values to the pins
  ledcWrite(1, R); // write red component to channel 1, etc.
  ledcWrite(2, G);   
  ledcWrite(3, B); 
 
  delay(100); // full cycle of rgb over 256 colors takes 26 seconds
 }
 
 digitalWrite(myLed, HIGH); delay(10); digitalWrite(myLed, LOW); // indicate end of cycle
}


// Courtesy http://www.instructables.com/id/How-to-Use-an-RGB-LED/?ALLSTEPS
// function to convert a color to its Red, Green, and Blue components.

void hueToRGB(uint8_t hue, uint8_t brightness)
{
    uint16_t scaledHue = (hue * 6);
    uint8_t segment = scaledHue / 256; // segment 0 to 5 around the
                                            // color wheel
    uint16_t segmentOffset =
      scaledHue - (segment * 256); // position within the segment

    uint8_t complement = 0;
    uint16_t prev = (brightness * ( 255 -  segmentOffset)) / 256;
    uint16_t next = (brightness *  segmentOffset) / 256;

    if(invert)
    {
      brightness = 255 - brightness;
      complement = 255;
      prev = 255 - prev;
      next = 255 - next;
    }

    switch(segment ) {
    case 0:      // red
        R = brightness;
        G = next;
        B = complement;
    break;
    case 1:     // yellow
        R = prev;
        G = brightness;
        B = complement;
    break;
    case 2:     // green
        R = complement;
        G = brightness;
        B = next;
    break;
    case 3:    // cyan
        R = complement;
        G = prev;
        B = brightness;
    break;
    case 4:    // blue
        R = next;
        G = complement;
        B = brightness;
    break;
   case 5:      // magenta
    default:
        R = brightness;
        G = complement;
        B = prev;
    break;
    }
}

[al1fch]

Pour comprendre comment ça marche :

gestion des PWM pour leds de l'ESP32, voir cet article de techtutorialsx
autre info : doc de l'IDF d'ESpressif sur LEDC
un fading automatique est possible

gestion de la modulation delta-sigma : voir la doc de l'IDF d'ESpressif (c'est lui qu'on utilise à travers une 'couche' Arduino). En cas de pb d'accès à cette page, repasser par le sommaire

[al1fch]

Bonsoir

autre voie d'accès, les essais !!

J'ai pris l'exemple SigmaDelta en le simplifiant pour observer l'effet de la déclaration de fréquence et du paramètre i

void setup()
{
    //setup channel 0 
    sigmaDeltaSetup(0, 1500); // 100 kHz
    
    //attach pin 18 to channel 0
    sigmaDeltaAttachPin(18,0);
    
    //initialize channel 0 to off
    sigmaDeltaWrite(0, 0);
}

void loop()
{
    static uint8_t i = 128;
    sigmaDeltaWrite(0, i);
    delay(10000);

}

Sur la pin 18 : oscilloscope et multimètre

Premier essais avec i=128 : un signal carré est bien observé comme attendu.
Surprise par contre pour la fréquence de ce signal, sans rapport avec le commentaire du programme de démo.

Voici les valeurs de fréquences relevées pour diverses valeurs passées en second paramètre dans SigmaDeltaSetup()

1 000 : 80 kHz
1 500 : 100 kHz
3 000 : 200 kHz
5 000 : 333 kHz
8 000 : 500 kHz
15 000 : 1 MHz

Second essais en variant la valeur de i, second paramètre de SigmaDeltaWrite()
Pas de signal périodique rectangulaire stable, à l'évidence on n'est pas en présence d'un PWM avec un rapport cyclique constant proportionnel à la valeur de i (contrairement à ce que pouvait laisser penser le beau signal carré pour i=128)
A l'oscilloscope et au multimètre on a plutôt l'impression de la 'densité' d'impulsions est ajustée (asservissement ?) de manière à ce que la valeur moyenne du signal produit soit bien proportionnelle à la valeur de i.
Pas de FFT dans mon vieux scope , je ne peux malheureusement voir l'effet sur le spectre et la différence avec un PWM.

Pour gérer un moteur ça peut sans doute fonctionner, idem pour un filtrage en vue de l'obtention d'une tension continue. Le changement 'au vol' de la valeur moyenne laisse entrevoir des applications audios basiques

la fonction AnalogWrite() qui gèrera sans doute les PWM classiques de l'ESP32 est toujours attendue, pour l'instant on a de quoi gérer les PWM spécialisés LED et le modulateur Sigma-Delta

[Artouste]

al1fch:
Bonsoir

autre voie d'accès, les essais !!

Bonsoir al1

Je vais lire plus tard ... le fond
Mais en tous cas , sur la forme c'est une belle et jolie rime riche ;D

[neo888]

Bonjour tout le monde.

Effectivement, le signal n'est pas vraiment périodique, je n'ai pas encore réussi à contrôler mon ventilo avec sigmaDelta, dans le moniteur je vois bien qu'il n'y a pas de périodicité ça s'emballe de manière aléatoire. Et pour le moment il n'y a pas de fade mais un tout ou rien.
Cette formule avait l'air plus simple (en tout cas sur l'écriture) mais je vais me rabattre sur la gestion pwm des leds (ledc) . En espérant que l'analogwrite arrive pour bientôt.
je vous tiens au courant.

[lesept]

neo888:
lesept , je comprends ce que tu veut dire et du coup 'value' ne dépassera jamais son seuil : 'valuemax'
en fait on calcul duty grâce à value qui est entre 0 et 255 (pour l'amplitude pwm)?

Non, ce n'est pas ce que j'ai dit. Dit autrement, le calcul de duty sera tolérant au dépassement du seuil valueMax par value. Tu peux faire la même chose avec les fonctions map et constrain.

[al1fch]

Bonjour

petit complément sur le résultat du Sigma Delta
cette fois çi avec analyseur logique et fréquencemètre

3 cas ci dessous (toujours pour 100kHz, donc 1500 dans sigmaDeltaSetup()
Consigne de rapports cycliques moyens : 1/3, 1/2 et 2/3 (rapports cycliques moyens effectifs confirmés sur le fréquencemètre)
Rapport cyclique 'instantanné' et parfois fréquence'paraissent ajustés (modulés) de manière à ce que le rapport cyclique moyen soit celui demandé.(asservissement ?)

[al1fch]

les 'PWM pour LED' intégrés a l"ESP32 sont utilisables à la manière d'AnalogWrite
(la doc hardware de l'ESP32 fait apparaître d'autres PWM spécialisés qui , présent au niveau hardware, nes sont pas encore exploitables : PWM moteurs....
ci dessous l'exemple 'fade' simplifié pour observer les signaux sur la pin18

/*
  LEDC Software Fade simplifié
*/

// use first channel of 16 channels (started from zero)
#define LEDC_CHANNEL_0     0

// use 13 bit precission for LEDC timer
#define LEDC_TIMER_13_BIT  13

// use 5000 Hz as a LEDC base frequency
#define LEDC_BASE_FREQ     5000

#define LED_PIN            18

int brightness = 0;    // how bright the LED is

// Arduino like analogWrite
// value has to be between 0 and valueMax
void ledcAnalogWrite(uint8_t channel, uint32_t value, uint32_t valueMax = 255) {
  // calculate duty, 8191 from 2 ^ 13 - 1
  uint32_t duty = (8191 / valueMax) * min(value, valueMax);

  // write duty to LEDC
  ledcWrite(channel, duty);
}

void setup() {
  // Setup timer and attach timer to a led pin
  ledcSetup(LEDC_CHANNEL_0, LEDC_BASE_FREQ, LEDC_TIMER_13_BIT);
  ledcAttachPin(LED_PIN, LEDC_CHANNEL_0);
}

void loop() {
  // set the brightness on LEDC channel 0
  brightness = 26;
  ledcAnalogWrite(LEDC_CHANNEL_0, brightness);
 
  delay(30);
}

Le résultat , içi avec duty=26 ,est bien celui qu'on attend d'un PWM,

[neo888]

J'ai vu ça ce matin, d'ailleurs ça marche bien avec le code ci-dessous.
par contre je n'arrive pas à récupérer les pulsations du ventilo pour afficher les trs/min.

Il y a bien la fonction pulseIn(pin, value, timeout) qui marchait dans mon ancienne configuration, qui à l'air bien reconnue dans la nouvelle, mais dont les valeurs sont erronées (ou bien est-ce le calcul rpm...)

est-ceque le programme vous semble bon?

/********************************************************************************************************/
/***                  FAIRE FONCTIONNER UN VENTILATEUR PWM AVEC ESP32 SANS ANALOGWRITE                ***/
/********************************************************************************************************/
/***                                          DÉCLARATIONS                                            ***/
/********************************************************************************************************/

#define FAN_PWM_CHANNEL     0           // Le canal pwm. Il y a 16 canaux (0-15)A utiliser dans l'ordre?
#define FAN_PULSE_CHANNEL   1           // Le canal pulse

#define RES_BIT             8           // La résolution

#define BASE_FREQ           12000       // La fréquence de base en Hz 
                                        // (j'ai laissé comme dans l'exemple des ledsRGB ratio 8bit 12Khz)
                                      
#define FAN_PIN_PWM         16          // Port sur lequel est connecté la broche pwm du ventilateur
#define FAN_PIN_PULSE       17          // Port sur lequel est connecté la broche tach du ventilateur 

int pwm = 0;                            // valeur entre 0 et 255 à envoyer au ventilateur
int fade= 5;                            // valeur d'incrémentation de pwm
unsigned long pulse;                    // variable de retour des pulsations fournie par le ventilateur.
unsigned int RPM = 0;                   // variable de conversion en trs/min

/********************************************************************************************************/
/***                                        ledcAnalogWrite()                                         ***/
/********************************************************************************************************/

void ledcAnalogWrite(uint8_t channel, uint32_t value, uint32_t valueMax = 255)
{
  uint32_t duty = (255 / valueMax) * min(value, valueMax);  // pour calculer duty, 255 = 2 ^ 8bits - 1
  ledcWrite(channel, duty);                                 // enregistre la valeur de duty
}


/********************************************************************************************************/
/***                                             setup()                                              ***/
/********************************************************************************************************/

void setup() 
{
  Serial.begin(115200);
  
  pinMode(FAN_PIN_PWM,OUTPUT);                       // sens de transmission des données de la broche pwm
  pinMode(FAN_PIN_PULSE,INPUT);                      // et de celle des pulsations
  
  digitalWrite(FAN_PIN_PULSE, HIGH);                 // Initialisation du signal sur haut
  
  ledcSetup(FAN_PWM_CHANNEL, BASE_FREQ, RES_BIT);    // Enregistre et attache les paramètres pwm
  ledcAttachPin(FAN_PIN_PWM, FAN_PWM_CHANNEL);
  
  /*ledcSetup(FAN_PULSE_CHANNEL, BASE_FREQ, RES_BIT);  // Enregistre et attache les paramètres pulse
  ledcAttachPin(FAN_PIN_PULSE, FAN_PULSE_CHANNEL);*/
}

void loop()
{
  ledcAnalogWrite(FAN_PWM_CHANNEL, pwm);             // Envoie au ventilateur la valeur pwm

  pwm = pwm + fade;                                  // Actualisation de pwm

  if (pwm <= 0 || pwm >= 255)                        // Inversion du sens si pwm atteint ses limites
  {
    fade = -fade;
  }
  
  pulse = pulseIn(FAN_PIN_PULSE, LOW);           
  RPM = (60 / (pulse / 1000000.0))/4;    

  Serial.println(pwm);
  Serial.println(RPM);
  
  delay(3000);
}

Oui il est clair que sigma ne correspond pas à la gestion pwm telle qu'on l'entend.
Ok lesept je vois ce que tu veux dire

[neo888]

Il existe PCNT pulse counter

pcnt_set_pin(pcnt_unit_t unit, pcnt_channel_t channel, int pulse_io, int ctrl_io)

Configure PCNT pulse signal input pin and control input pin.

Note
Set to PCNT_PIN_NOT_USED if unused.
Note
Set to PCNT_PIN_NOT_USED if unused.
Return

ESP_OK Success
ESP_ERR_INVALID_ARG Parameter error

Parameters

unit: PCNT unit number
channel: PCNT channel number
pulse_io: Pulse signal input GPIO

Parameters

ctrl_io: Control signal input GPIO

Faut que je vois comment faire fonctionner