Reset externe Wemos D1 mini après Deep Sleep

Bonjour à tous,
Pour mon projet, j'utilise une carte Pro Micro (Leonardo) et une Wemos D1 mini (Esp8266).
Je souhaite faire un reset sur la carte wemos avec une sortie (D3) de la carte pro micro.
Ca fonctionne bien tant que la wemos n'est pas en deep sleep, mais je ne sais pour quelle raison, si la carte wemos est en deep sleep, le reset généré par la Pro Micro n'est pas pris en compte.
Avec un oscillo, j'ai pu voir que le signal sur la borne reset ne passait pas à 0V, mais est d'environ 2,6v. Avez vous une idée de mon problème ?

Hello everyone,
For my project I am using a Pro Micro card (Leonardo) and a Wemos D1 mini (Esp8266).
I want to reset the wemos card with an output (D3) from the pro micro card.
It works well as long as the wemos is not in deep sleep, but I don't know for what reason, if the wemos card is in deep sleep, the reset generated by the Pro Micro is not taken into account.
With an oscillo, I could see that the signal on the reset terminal did not go to 0V, but is around 2.6v. Do you have any idea of my problem?

Thanks

Bonjour

Schéma complet du montage ?
Code ?

Bien prendre connaissance , dans les "Bonnes Pratiques du Forum Francophone" , des informations à fournir pour toute demande d'aide + inutile de perdre du temps içi avec une version anglaise de la demande !!

Les masses des deux cartes sont bien connectées entre elles ?

Bonjour, je n'ai pas fait de schéma pour le moment, D'ailleurs si vous avez un logiciel abordable à me conseiller, je suis preneur. J'ai essayé KiCad, mais je n'ai pas accroché.
Pour la partie Reset, rien de spécial, la sortie digital 3 de la carte Pro Micro est directement relié à la broche RST de la carte Wemos. Les masses sont bien reliées, l'alimentation est la même pour les deux cartes.
Schéma carte Pro Micro
Infos Wemos D1 mini

Le code de la fonction Reset :

void Reset_Wifi()
{
  Serial.println("Reset Wifi");
  digitalWrite(3, LOW);
  delay(20);
  digitalWrite(3, HIGH);
}

Le code complet de la carte Pro Micro:

#include <Arduino.h>

#include <Keyboard.h> // Keyboard - Version: 1.0.2
#include <avr/wdt.h> // watchdog
#include <avr/power.h> // sleep mode
#include <OneWire.h>
#include <DallasTemperature.h>
#include <BlynkSimpleStream.h>

#define POWER_ON 1
#define POWER_OFF 0
#define LED_RGB_R A0
#define LED_RGB_V A1
#define LED_RGB_B A2
#define ONE_WIRE_BUS 6 // Broche du bus 1-Wire
#define TEMPERATURE_PRECISION 9 // 9 à 12 bits
#define TIME_OUT_WIFI 30000L //eteint après 6H00 connecté (21600000)
#define TIME_OUT_PC 600000 // coupe l'alimentation du PC après 6 min suite à la demande d'extinction
#define TIME_ON_PC 120000 // temps avant changement possible d'état du PC
const byte N_MESURES_BATT = 10; // Définition du nombre d'échantillons pour le calcul de la moyenne tension batterie
const unsigned long Duree_Anti_Rebond = 2000; // filtre sur l'alimentation allume cigare

// Setup a oneWire instance to communicate with any OneWire devices (not just Maxim/Dallas temperature ICs)
OneWire oneWire(ONE_WIRE_BUS);

// Pass our oneWire reference to Dallas Temperature. 
DallasTemperature sensors(&oneWire);

// Tableaux contenant l'adresse de chaque sonde OneWire 
DeviceAddress T_Batteries = { 0x28,  0xFF,  0x64,  0x1D,  0xF9,  0x9B,  0xE0,  0xE9 };

float Tension_AllumeCigare=0, Tension_batteries=0, Temperature_Batt=0, Courant_Chargeur=0, Courant_PC=0;
bool Etat_Alim=0, Etat_Alim_PRECEDENT=0, Etat_Fixe_Precedent_Alim=0, Changement_Etat_Alim = 0;
unsigned long Date_Changement_Etat_Alim, Tempo = 0, Date_Timer_Wifi=0, Date_Timer_Demarrage_PC=0, Date_Timer_Arret_PC=0;
String command = "";
bool Command_Allumage_PC=0, Command_Extinction_PC=0, Command_Extinction_PC_Synchro=0, Command_Extinction_PC_en_cours=0, Command_Allumage_Ecran=0, Command_Extinction_Ecran=0;
bool Command_Allumage_Chargeur = 0, Command_Extinction_Chargeur=0, Command_Reset_Wifi=0, Time_Out_PC_Extinction_Variable=0;
bool Pre_Alarme_Temperature=0, Alarme_Temperature=0, Alarme_Tension_Batteries=0, Pre_Alarme_Tension_Batteries=0;
float Total_Tension_Batteries=0, Moyenne_Tension_batteries=0;
byte Index_MesuresBatterie=0, Index_Control_PC=0, Command_Allumage_PC_Compteur=0, Compteur_Wifi_Disconnected=0;
bool Detection_Rebond_Alim=0, BlynkConnected=0;
unsigned int Detection_Rebond_Alim_Compteur=0;
bool Message_Probleme_demarrage_PC=0, Message_PC_demarre=0, Message_demarrage_du_PC=0, Message_Reset_PC=0;
bool Message_PC_Extinction = 0, Message_PC_Extinction_Synchro = 0;

// the timer object
BlynkTimer timer;
int timer_Controls;
int timerWifi;
int timerPC_Extinction;
int timerPC_Reset;
int timerWifi_Reset;
int timerPC_Demarre;

//déclaration des fonctions
void Controls();
void Control_Temperature_Batteries();
void Control_Tension_Batteries();
void Control_AllumeCigare();
void Control_Chargeur();
void Control_PC();
void Control_Wifi();
void Control_Ecran();
void Allumer_Chargeur();
void Allumer_PC(); 
void Allumer_Ecran();
void Eteindre_Wifi();
void Eteindre_Ecran();
void Eteindre_Chargeur();
void Eteindre_PC(bool); // true : avec synchro
void Redemarrer_PC();
void Redemarrer_force_PC();
void Reset_Board();
void Reset_PC();
void Reset_Wifi();
void Mesure_Tension_Batteries();
void Mesure_Tension_AllumeCigare();
void Mesure_Courant_PC();
unsigned int analogReadReference(void);
void LectureTemperature(String label, DeviceAddress deviceAddress);
void Serial1_reception();
void BlynkConnection();
void BlynkDisconnection(); 
void Time_Out_PC_Extinction();
void Time_Out_PC_Reset();
void Time_Out_Wifi_Connexion();
void Time_Out_PC_Demarre();
void Send_Blynk();


void Controls() //timer se déclanche toutes les secondes
{
  digitalWrite(LED_RGB_V, HIGH);
  Control_Temperature_Batteries();
  Control_Tension_Batteries();
  Control_AllumeCigare();
  Control_Chargeur();
  Control_PC();
  Control_Wifi();
  Control_Ecran(); 
  digitalWrite(LED_RGB_V, LOW);
}

void Send_Blynk()
{
  digitalWrite(LED_RGB_B, HIGH);
  if (Detection_Rebond_Alim)
  {
    Serial1.print("I 01 "); //Rebond détecté sur alim
    Serial1.print(Detection_Rebond_Alim_Compteur);
    Serial1.println();
    Detection_Rebond_Alim = false;
  }
  if (digitalRead(7)) Serial1.print("I 02"); // Chargeur allumé
  else Serial1.print("I 03"); // Chargeur éteint
  Serial1.println();
  if (digitalRead(4)) Serial1.print("I 04"); // PC allumé
  else Serial1.print("I 05"); // PC éteint
  Serial1.println();
  if (digitalRead(5)) Serial1.print("I 06"); // Ecran allumé
  else Serial1.print("I 07"); // Ecran éteint
  Serial1.println();
  Serial1.print("I 08 "); // Mesure Courant PC
  Serial1.print(Courant_PC, 1);
  Serial1.println();
  Serial1.print("I 09 "); // Moyenne tension batterie
  Serial1.print(Moyenne_Tension_batteries, 1);
  Serial1.println();
  Serial1.print("I 10 "); // Mesure température batterie
  Serial1.print(Temperature_Batt,1);
  Serial1.println();
  Serial1.print("I 11 "); // Mesure tension alim
  Serial1.print(Tension_AllumeCigare, 1);  
  Serial1.println();
  if (Alarme_Temperature) Serial1.print("I 12"); // Alarme Temperature
  else if (Pre_Alarme_Temperature) Serial1.print("I 13"); // Pré Alarme Temperature
  else Serial1.print("I 14"); // Temperature OK
  Serial1.println();
  if (Alarme_Tension_Batteries) Serial1.print("I 15"); // Alarme Tension Batteries
  else if (Pre_Alarme_Tension_Batteries) Serial1.print("I 16"); // Pré Alarme Tension Batteries
  else Serial1.print("I 17"); // Tension Batteries OK
  Serial1.println();
  Serial1.print("I 18 "); // Timer avant extinction wifi
  unsigned long Timer_Wifi_Status = ( TIME_OUT_WIFI - ( millis() - Date_Timer_Wifi ) ) / 1000;
  Serial1.print(Timer_Wifi_Status);
  Serial1.println();
  Serial.print("Timer Wifi: ");
  Serial.println(Timer_Wifi_Status);
  if (Index_Control_PC == 7)
  {
    Serial1.print("I 19 "); // Timer avant extinction forcée du PC
    unsigned long Timer_PC_Status = ( TIME_OUT_PC - ( millis() - Date_Timer_Arret_PC ) ) / 1000;
    Serial1.print(Timer_PC_Status);
    Serial1.println();
    Serial.print("Timer arrêt PC: ");
    Serial.println(Timer_PC_Status);
  }
  if (Index_Control_PC == 4)
  {
    Serial1.print("I 20 "); // Timer démarrage du PC
    unsigned long Timer_PC_Status = ( TIME_ON_PC - ( millis() - Date_Timer_Demarrage_PC ) ) / 1000;
    Serial1.print(Timer_PC_Status);
    Serial1.println();
    Serial.print("Timer démarrage PC: ");
    Serial.println(Timer_PC_Status);
  }
  if (Message_Probleme_demarrage_PC)
  {
    Message_Probleme_demarrage_PC = false;
    Serial1.print("M 01"); // Problème démarrage PC
    Serial1.println();
  } 
  if (Message_PC_demarre)
  {
    Message_PC_demarre = false;
    Serial1.print("M 02"); // PC démarré
    Serial1.println();
  }  
  if (Message_demarrage_du_PC)
  {
    Message_demarrage_du_PC = false;
    Serial1.print("M 03"); // Allumage du PC en cours
    Serial1.println();
  }
  if (Message_Reset_PC)
  {
    Message_Reset_PC = false;
    Serial1.print("M 04"); // Reset du PC en cours
    Serial1.println();
  }
  if (Message_PC_Extinction_Synchro)
  {
    Message_PC_Extinction_Synchro = false;
    Serial1.print("M 05"); // Synchro et Extinction du PC en cours
    Serial1.println();
  }
  if (Message_PC_Extinction)
  {
    Message_PC_Extinction = false;
    Serial1.print("M 06"); // Extinction du PC en cours
    Serial1.println();
  }
  digitalWrite(LED_RGB_B, LOW);
}


void setup()
{
  wdt_disable();
  pinMode(LED_RGB_R, OUTPUT); // Led RGB Rouge(A0)
  pinMode(LED_RGB_V, OUTPUT); // Led RGB Vert(A1)
  pinMode(LED_RGB_B, OUTPUT); // Led RGB Bleu(A2)
  pinMode(A3, INPUT); // Alimentation allume-cigare; pont diviseur (10k-2k) rapport 1/6
  pinMode(A8, INPUT); // MAX471 Lecture d'intensité du PC (1V = 1A)
  pinMode(A9, INPUT); // Alimentation batterie; pont diviseur (10k-3.3k) rapport 1/4.03
  pinMode(A10, INPUT); // MAX471 Lecture d'intensité du Chargeur (1V = 1A) *****grillée*****
  pinMode(2, OUTPUT); // bouton marche/arret PC (optocoupleur 4N35)
  pinMode(3, OUTPUT); // Reset WeMos D1 mini (ESP8266)
  digitalWrite(3, HIGH);
  pinMode(4, OUTPUT); // Commande alimentation PC
  pinMode(5, OUTPUT); // Commande alimentation Ecran
  //pinMode(6, INPUT); // Capteur de température DS18B20
  pinMode(7, OUTPUT); // Commande alimentation Chargeur Batteries
  pinMode(16, INPUT); // MAX471 Lecture du signe du courant du Chargeur
  Serial.begin(115200); // COM avec PC
  Serial1.begin(19200); // COM avec ESP8266 
  Keyboard.begin();
  sensors.begin(); // Start up the library for onewire
  sensors.setResolution(T_Batteries, TEMPERATURE_PRECISION);
  //while (!Serial1);
  timer_Controls = timer.setInterval(1000L, Controls);
  Reset_Wifi();
  Serial.println("******************Setup terminé*******************");
  //wdt_enable(WDTO_2S); // active le watchdog
}



void loop()
{
  //wdt_reset(); // Réarme le watchdog
  Serial1_reception();
  timer.run();
}

void Serial1_reception()
{
 if(Serial1.available()>0)
  {
     command = Serial1.readStringUntil('\n');
     command.trim();
     Serial.println("Commande reçu: " + command);
     if(String("Item 1") == command) Command_Allumage_PC = true;  //allumer PC
     else if(String("Item 2") == command) Command_Extinction_PC_Synchro = true; // extinction du pc après synchronisation de la musique
     else if(String("Item 3") == command) Command_Extinction_PC = true; // extinction du pc sans synchro
     else if(String("Item 4") == command) Redemarrer_PC();
     else if(String("Item 5") == command) Redemarrer_force_PC();
     else if(String("Item 6") == command) Reset_PC();
     else if(String("Item 7") == command) Reset_Wifi();
     else if(String("Item 8") == command) Command_Allumage_Ecran = true;
     else if(String("Item 9") == command) Command_Extinction_Ecran = true;
     else if(String("Item 10") == command) Reset_Board();
     else if(String("Blynk connected") == command) BlynkConnection();
     else if(String("Blynk disconnected")== command) BlynkDisconnection(); 
     else;    //Serial1.println("Commande invalide reçu");
  }
}

void Control_Chargeur()
{
  if (Command_Allumage_Chargeur)
  {
    Allumer_Chargeur();
    Command_Allumage_Chargeur = false;
  }
  if (Command_Extinction_Chargeur)
  {
    Eteindre_Chargeur();
    Command_Extinction_Chargeur = false;
  }
  if (Pre_Alarme_Temperature || Alarme_Temperature) Command_Extinction_Chargeur = true;
}

void BlynkDisconnection()
{  
  BlynkConnected = false;
  Serial.println("***Blynk disconnected***");
}

void BlynkConnection()
{      
  if(BlynkConnected)
  {
    Serial.println("***Blynk connected, timer enable***");
    Send_Blynk();
  } 
  else
  {
    BlynkConnected = true;
    Serial.println("***Blynk connected***");
    timerWifi = timer.setTimeout(TIME_OUT_WIFI, Time_Out_Wifi_Connexion); 
    Date_Timer_Wifi = millis();
  }
}

void Time_Out_Wifi_Connexion()
{
  Serial.println("Time Out Wifi Connexion");
  Eteindre_Wifi();
}

void Mesure_Courant_PC()
{
  const int nEchantillons = 10; // Définition du nombre d'échantillons pour le calcul de la moyenne
  float echantillon[nEchantillons];    // un tableau pour stocker les échantillons lus
  float total=0;
  unsigned int Mesure_Vref = analogReadReference(); // Mesure la référence interne à 1.1 volts
  for (int i = 0; i < nEchantillons; i++) echantillon[i] = 0; // On remplit le tableau d'échantillons avec des 0
  for (int i = 0; i < nEchantillons; i++)
  { 
    unsigned int Mesure = analogRead(A8); // Mesure la tension 
    echantillon[i] = ((Mesure * 1.1) / Mesure_Vref); // Calcul de la tension réel
    total = total + echantillon[i]; // Ajout du dernier echantillon
  }
  Courant_PC = total / nEchantillons; // calcul de la moyenne
  Serial.print("Mesure Courant PC: ");
  Serial.println(Courant_PC, 1);
}

void Control_PC()
{
  Mesure_Courant_PC();
  switch (Index_Control_PC)
  {
    case 0: // Initialisation
      Serial.println("Etape 0");
      Command_Allumage_PC= false;
      Command_Extinction_PC= false;
      Command_Allumage_PC_Compteur = 0;
      Message_PC_demarre = false;
      Message_PC_Extinction = false;
      Message_PC_Extinction_Synchro = false;
      Message_Probleme_demarrage_PC = false;
      Message_Reset_PC = false;
      digitalWrite(4, LOW);
      Command_Extinction_Ecran = true; 
      Time_Out_PC_Extinction_Variable = false;
      Index_Control_PC++;
    case 1:
      Serial.println("Etape 1");
      if (Command_Allumage_PC && !(Alarme_Temperature || Alarme_Tension_Batteries || Pre_Alarme_Tension_Batteries)) Index_Control_PC++;
      else break;
    case 2:
      Serial.println("Etape 2");
      if (Courant_PC > 0.2) Index_Control_PC++;
      else 
      {
        switch (Command_Allumage_PC_Compteur)
        {
          case 0:
            Allumer_PC();
            break;
          case 3:
            Allumer_PC();
            break;
          case 6:
            Allumer_PC();
            break;
          case 9:
            Reset_PC();
            break;
          case 20:
            Message_Probleme_demarrage_PC = true;
            Index_Control_PC = 0;
            return;
          default:
            break;
        }
        Command_Allumage_PC_Compteur++;
        break;
      }  
    case 3:
      Serial.println("Etape 3");
      Message_PC_demarre = true;
      if (Etat_Alim) Command_Allumage_Ecran = true;
      timerPC_Demarre = timer.setTimeout(TIME_ON_PC, Time_Out_PC_Demarre);
      Date_Timer_Demarrage_PC = millis();
      Index_Control_PC++;
    case 4: // Attend 2 min que le PC démarre
      Serial.println("Etape 4");
      if (Courant_PC < 0.2)
      {
        Index_Control_PC = 0;
        timer.deleteTimer(timerPC_Demarre);
      } 
      break;
    case 5:
      Serial.println("Etape 5");
      if (Courant_PC < 0.2) Index_Control_PC = 0;
      if (Alarme_Temperature || Alarme_Tension_Batteries || Command_Extinction_PC)
      {
        Eteindre_PC(false);
        Index_Control_PC++;
      } 
      else if (Command_Extinction_PC_Synchro)
      {
        Eteindre_PC(true);
        Index_Control_PC++;
      } 
      break;
    case 6:
      Serial.println("Etape 6");
      timerPC_Extinction = timer.setTimeout(TIME_OUT_PC, Time_Out_PC_Extinction); // 600000 (10 min)
      Date_Timer_Arret_PC = millis();
      Index_Control_PC++;
      break;
    case 7:
      Serial.println("Etape 7");
      if(Time_Out_PC_Extinction_Variable) Index_Control_PC = 0;
      if (Courant_PC < 0.2) 
      {
        Index_Control_PC = 0;
        timer.deleteTimer(timerPC_Extinction);
      }
      break;  
    default:
      Index_Control_PC = 0;
      break;
  }
}

void Time_Out_PC_Demarre()
{
  Index_Control_PC++;
}

void Control_Wifi()
{
  if (Command_Reset_Wifi)
  {
    Reset_Wifi();
    Command_Reset_Wifi = false;
    timerWifi = timer.setTimeout(TIME_OUT_WIFI, Time_Out_Wifi_Connexion); 
  }
}

void Control_Ecran()
{
  if ((Alarme_Tension_Batteries || Pre_Alarme_Temperature || Alarme_Temperature) && digitalRead(5)) Command_Extinction_Ecran = true;
  if (Command_Extinction_Ecran) 
  {
    Eteindre_Ecran();
    Command_Extinction_Ecran = false;
    Command_Allumage_Ecran = false;
  }
  else if (Command_Allumage_Ecran)
  {
    Allumer_Ecran();
    Command_Allumage_Ecran = false;
  }
}

void Mesure_Tension_AllumeCigare()
{
  Serial.print("Tension Allume Cigare: ");
  const int nEchantillons = 10; // Définition du nombre d'échantillons pour le calcul de la moyenne
  float echantillon[nEchantillons];    // un tableau pour stocker les échantillons lus
  float total=0;
  unsigned int Mesure_Vref = analogReadReference(); // Mesure la référence interne à 1.1 volts
  for (int i = 0; i < nEchantillons; i++)
  { 
    unsigned int Mesure = analogRead(A3); // Mesure la tension 
    echantillon[i] = ((Mesure * 1.1) / Mesure_Vref)*6; // Calcul de la tension réel
    total = total + echantillon[i]; // Ajout du dernier echantillon
  }
  Tension_AllumeCigare = total / nEchantillons; // calcul de la moyenne
  Serial.println(Tension_AllumeCigare, 1);
}

void Control_AllumeCigare()
{
  Mesure_Tension_AllumeCigare();
  if (Tension_AllumeCigare > (Tension_batteries+0.2)) Etat_Alim=POWER_ON;
  else 
  {
    Etat_Alim=POWER_OFF;  
    Tension_AllumeCigare=0;
  }
  if (Etat_Alim != Etat_Alim_PRECEDENT) // détection changement d'état alimentation
  {
    Date_Changement_Etat_Alim = millis();
    Etat_Alim_PRECEDENT = !Etat_Alim_PRECEDENT;
    Changement_Etat_Alim = 1;
  }
  if (((millis() - Date_Changement_Etat_Alim) > Duree_Anti_Rebond) && Changement_Etat_Alim)
  {
    Changement_Etat_Alim = 0;
    if (Etat_Fixe_Precedent_Alim != Etat_Alim)
    {
      Etat_Fixe_Precedent_Alim = Etat_Alim;
      if (Etat_Alim == POWER_ON) 
      {
        Command_Extinction_Chargeur = false;
        Command_Allumage_Chargeur = true;
        Command_Reset_Wifi = true;
        Command_Extinction_PC = false;
        Command_Extinction_PC_Synchro = false;
        Command_Allumage_PC = true; 
        Command_Extinction_Ecran = false;
        Command_Allumage_Ecran = true;
      }
      else
      {
        Command_Extinction_Chargeur = true;
        Command_Allumage_Chargeur = false;
        Command_Reset_Wifi = true;
        Command_Extinction_PC = false;
        Command_Extinction_PC_Synchro = true; 
        Command_Allumage_PC = false;
        Command_Extinction_Ecran = true;
        Command_Allumage_Ecran = false;
      }
    }
    else
    {
      Serial.println("********Rebond détecté sur alim********");
      Detection_Rebond_Alim_Compteur++;
      Detection_Rebond_Alim = true;
    }
  }
}

void Mesure_Tension_Batteries()
{
  Serial.print("Tension Batterie: ");
  const int nEchantillons = 10; // Définition du nombre d'échantillons pour le calcul de la moyenne
  float echantillon[nEchantillons];    // un tableau pour stocker les échantillons lus
  float total=0;
  unsigned int Mesure_Vref = analogReadReference(); // Mesure la référence interne à 1.1 volts
  for (int i = 0; i < nEchantillons; i++)
  { 
    unsigned int Mesure = analogRead(A9); // Mesure la tension 
    echantillon[i] = ((Mesure * 1.1) / Mesure_Vref)*4.02; // Calcul de la tension réel
    total = total + echantillon[i]; // Ajout du dernier echantillon
  }
  Tension_batteries = total / nEchantillons; // calcul de la moyenne
  Serial.println(Tension_batteries, 1);
}

void Control_Tension_Batteries()
{
  Mesure_Tension_Batteries();
  Total_Tension_Batteries = Total_Tension_Batteries + Tension_batteries;
  if (Index_MesuresBatterie++ == (N_MESURES_BATT-1))
  {
    Index_MesuresBatterie=0;
    Moyenne_Tension_batteries = Total_Tension_Batteries / N_MESURES_BATT;
    Serial.print("Moyenne tension batterie :");
    Serial.println(Moyenne_Tension_batteries, 1);  
    if (Moyenne_Tension_batteries < 8.9) Alarme_Tension_Batteries = true;
    if (Moyenne_Tension_batteries < 11) Pre_Alarme_Tension_Batteries = true;
    if (Moyenne_Tension_batteries > 10) Alarme_Tension_Batteries = false;
    if (Moyenne_Tension_batteries > 11.5) Pre_Alarme_Tension_Batteries = false;
    Total_Tension_Batteries=0;
  }
}

unsigned int analogReadReference(void) // Mesure la référence interne à 1.1 volts 
{
/* Elimine toutes charges résiduelles */
#if defined(__AVR_ATmega328P__)
  ADMUX = 0x4F;
#elif defined(__AVR_ATmega2560__)
  ADCSRB &= ~(1 << MUX5);
  ADMUX = 0x5F;
#elif defined(__AVR_ATmega32U4__)
  ADCSRB &= ~(1 << MUX5);
  ADMUX = 0x5F;
#endif
  delayMicroseconds(5);
  
  /* Sélectionne la référence interne à 1.1 volts comme point de mesure, avec comme limite haute VCC */
#if defined(__AVR_ATmega328P__)
  ADMUX = 0x4E;
#elif defined(__AVR_ATmega2560__)
  ADCSRB &= ~(1 << MUX5);
  ADMUX = 0x5E;
#elif defined(__AVR_ATmega32U4__)
  ADCSRB &= ~(1 << MUX5);
  ADMUX = 0x5E;
#endif
  delayMicroseconds(200);

  /* Active le convertisseur analogique -> numérique */
  ADCSRA |= (1 << ADEN);
  
  /* Lance une conversion analogique -> numérique */
  ADCSRA |= (1 << ADSC);
  
  /* Attend la fin de la conversion */
  while(ADCSRA & (1 << ADSC));
  
  /* Récupère le résultat de la conversion */
  return ADCL | (ADCH << 8);
}

void Control_Temperature_Batteries()
{
  LectureTemperature("Température Batteries: ",T_Batteries);
  if (Temperature_Batt > 35 || Temperature_Batt < 5)
  {
    Alarme_Temperature=true;
    Pre_Alarme_Temperature=true;
  } 
  else if (Temperature_Batt > 8 && Temperature_Batt < 29)
  {
    Alarme_Temperature=false;
    Pre_Alarme_Temperature=false;
  } 
  else if (Temperature_Batt < 6 || Temperature_Batt > 30)
  {
    Alarme_Temperature=false;
    Pre_Alarme_Temperature=true;
  }
}

void LectureTemperature(String label, DeviceAddress deviceAddress)
{
  sensors.requestTemperatures();
  Temperature_Batt = sensors.getTempC(deviceAddress);
  Serial.print(label);
  if (Temperature_Batt == -127.00) Serial.println("Error getting temperature");
  else 
  {
    Serial.println(Temperature_Batt,1);
  }
}

void Reset_Board()
{
  Serial.println("Reset de la carte en cours");
  wdt_enable(WDTO_120MS); // active le watchdog
  while(1); // Reset arduino par watchdog
}  
  
void Allumer_Chargeur()
{
  Serial.println("Allumer Chargeur");
  digitalWrite(7, HIGH);
}

void Eteindre_Chargeur()
{
  Serial.println("Eteindre Chargeur");
  digitalWrite(7, LOW);
}

void Eteindre_Wifi()
{
  timer.disable(timerWifi);
  Serial.println("Eteindre Wifi");
  Serial1.print("DeepSleep ");
  Serial1.println();
}

void Reset_Wifi()
{
  Serial.println("Reset Wifi");
  digitalWrite(3, LOW);
  delay(20);
  digitalWrite(3, HIGH);
}

void Redemarrer_force_PC()
{
  Serial.println("Redémarrage forcé du PC en cours");
  Keyboard.press(KEY_LEFT_CTRL);
  Keyboard.press(KEY_LEFT_ALT);
  Keyboard.press('f');
  Keyboard.releaseAll(); // reboot le pc
}

void Redemarrer_PC()
{
  Serial.println("Redémarrage du PC en cours");
  Keyboard.press(KEY_LEFT_CTRL);
  Keyboard.press(KEY_LEFT_ALT);
  Keyboard.press('r');
  Keyboard.releaseAll(); // reboot le pc
}

void Reset_PC()
{
  Serial.println("Reset PC en cours");
  Message_Reset_PC = true;
  digitalWrite(2, HIGH); // appuie sur le Bouton Marche
  timerPC_Reset = timer.setTimeout(3000, Time_Out_PC_Reset); //3 secondes pour extinction forcé du PC
  digitalWrite(LED_RGB_R, HIGH); 
}

void Time_Out_PC_Reset()
{
  digitalWrite(LED_RGB_R, LOW);
  digitalWrite(2, LOW);
}

void Allumer_PC()
{
  Serial.println("Allumage du PC en cours");
  Message_demarrage_du_PC = true;
  digitalWrite(4, HIGH);
  /*delay(500);
  digitalWrite(2, HIGH); // Bouton ON/OFF
  delay(500);
  digitalWrite(2, LOW);*/
}

void Eteindre_PC(bool Synchro)
{
  if (Synchro)
  {
    Serial.println("Synchro et Extinction du PC en cours");
    Message_PC_Extinction_Synchro = true;
    Keyboard.press(KEY_LEFT_CTRL);
    Keyboard.press(KEY_LEFT_ALT);
    Keyboard.press('b'); // lance le fichier 'Auto_DS418_Musique.ffs_batch'
  }
  else
  {
    Serial.println("Extinction du PC en cours");
    Message_PC_Extinction = true;
    Keyboard.press(KEY_LEFT_CTRL);
    Keyboard.press(KEY_LEFT_ALT);
    Keyboard.press('s'); 
  }
  Keyboard.releaseAll(); // envoi la combinaison de touches
}

void Time_Out_PC_Extinction()
{
  Serial.println("Time out,forçage extinction PC");
  Time_Out_PC_Extinction_Variable = true;
}

void Allumer_Ecran()
{
  Serial.println("Allumer Ecran");
  digitalWrite(5, HIGH);
}

void Eteindre_Ecran()
{
  Serial.println("Eteindre Ecran");
  digitalWrite(5, LOW);
}

Le code complet de la carte Wemos:

#include <Arduino.h>

#include <ESP8266WiFi.h>
#include <BlynkSimpleEsp8266.h> // pour utiliser l'application Blynk sur smartphone
// includes necessaires au fonctionnement de l'OTA : programmation par wifi
#include <WiFiUdp.h>
#include <ArduinoOTA.h>

// You should get Auth Token in the Blynk App.
// Go to the Project Settings (nut icon).
char auth[] = "***";

// Your WiFi credentials.
// Set password to "" for open networks.
char ssid[] = "***";
char pass[] = "***";

// Déclaration des fonctions
void Serial_reception();
void Initialisation_Blynk();
void splitString(String message, char separator);

// Déclaration des variables
String inputString = "";   // chaine de caractères pour contenir les données
boolean stringComplete = false;  // pour savoir si la chaine est complète
int cnt = 0; // nombre de données découpées
String data[10]; // stockage des données découpées

// Déclaration des Widgets
WidgetTerminal terminal(V0);
WidgetLED LED_PC(V1);
WidgetLED LED_TV(V5);
WidgetLED LED_CHG(V8);
BlynkTimer timer;

void Initialisation_Blynk()
{
  terminal.clear(); // Clear the terminal content
  terminal.flush();
  terminal.println(F("PC Auto By Super BeuBeu : Ready"));
  terminal.println(F("-------------------------------"));
  terminal.flush();
  Blynk.virtualWrite(V3, 0);
  Blynk.virtualWrite(V4, 0);
  Blynk.virtualWrite(V6, 0);
  Blynk.virtualWrite(V7, 0);
  Blynk.virtualWrite(V9, 0); // rebond
  Blynk.virtualWrite(V11, 0);
  Blynk.virtualWrite(V12, 0);
}

BLYNK_WRITE(V2) {
  terminal.print(F("Commande envoyée: "));
  switch (param.asInt())
  {
    case 1: // Item 1
      terminal.println("Allumer PC");
      Serial.print("Item 1");
      break;
    case 2: // Item 2
      terminal.println("Arrêt PC avec synchro");
      Serial.print("Item 2");
      break;
    case 3: // Item 3
      terminal.println("Arrêter PC sans synchro");
      Serial.print("Item 3");
      break;
    case 4: // Item 4
      terminal.println("Redémarrer PC");
      Serial.print("Item 4");
      break;
    case 5: // Item 5
      terminal.println("Redémarrage PC forcé");
      Serial.print("Item 5");
      break;
    case 6: // Item 6
      terminal.println("Reset PC");
      Serial.print("Item 6");
      break;
    case 7: // Item 7
      terminal.println("Reset Wifi");
      Serial.print("Item 7");
      break;
    case 8: // Item 8
      terminal.println("Allumer écran");
      Serial.print("Item 8");
      break;
    case 9: // Item 9
      terminal.println("Eteindre écran");
      Serial.print("Item 9");
      break;
    case 10: // Item 10
      terminal.println("Reset de la carte");
      Serial.print("Item 10");
      break;  
    default:
      terminal.println("Unknown item selected");
  }
  terminal.flush();
}

void BlynkServer()
{
  if (Blynk.connected())
  {
    Serial.print("Blynk connected");
    Serial.println();
  } 
  else 
  {
    Serial.print("Blynk disconnected");
    Serial.println();
    delay(50);
    ESP.deepSleep(0);
  }  
}

void setup()
{
  Serial.begin(19200);
  Blynk.begin(auth, ssid, pass, IPAddress(192, 168, 1, 31), 8080);
  //ArduinoOTA.setHostname("ESP8266AUTO"); // on donne un petit nom a notre module
  //ArduinoOTA.begin(); // initialisation de l'OTA
  Initialisation_Blynk();
  timer.setInterval(1000, BlynkServer);
}

void loop()
{
  //ArduinoOTA.handle();
  Blynk.run();
  timer.run(); // Initiates BlynkTimer
  Serial_reception();
}

void splitString(String message, char separator) {
  int index = 0;
  cnt = 0;
    do {
      index = message.indexOf(separator); 
      // s'il y a bien un caractère séparateur
      if(index != -1) { 
          // on découpe la chaine et on stocke le bout dans le tableau
          data[cnt] = message.substring(0,index); 
          cnt++;
          // on enlève du message le bout stocké
          message = message.substring(index+1, message.length());
      } else {
         // après le dernier espace   
         // on s'assure que la chaine n'est pas vide
         if(message.length() > 0) { 
           data[cnt] = message.substring(0,index); // dernier bout
           cnt++;
         }
      }
   } while(index >=0); // tant qu'il y a bien un séparateur dans la chaine
}

void Serial_reception()
{
  if (Serial.available())
  { 
    inputString = Serial.readStringUntil('\n');
    inputString.trim();
    splitString(inputString, ' '); // on le découpe à chaque espace ' ' et on stocke les bouts dans un tableau
 
    if (data[0] == "Status") BlynkServer();
    if (data[0] == "DeepSleep") ESP.deepSleep(0);
    if (data[0] == "I") 
    {
      switch (data[1].toInt())
      {
      case 1: // Rebond détecté sur alim
        terminal.println(F("Message reçu: Rebonds détecté sur alim"));  
        Blynk.virtualWrite(V9, data[2].toInt());
        break;
      case 2: // Chargeur allumé
        LED_CHG.on();
        Blynk.setProperty(V8, "color", "#23C48E"); //led verte
        break;
      case 3: // Chargeur éteint
        LED_CHG.on();
        Blynk.setProperty(V8, "color", "#999999"); // led Gris
        break;
      case 4: // PC allumé
        LED_PC.on();
        Blynk.setProperty(V1, "color", "#23C48E"); //led verte
        break;
      case 5: // PC éteint
        LED_PC.on();
        Blynk.setProperty(V1, "color", "#999999"); // led Gris
        break;
      case 6: // Ecran allumé
        LED_TV.on();
        Blynk.setProperty(V5, "color", "#23C48E"); //led verte
        break;
      case 7: // Ecran éteint
        LED_TV.on();
        Blynk.setProperty(V5, "color", "#999999"); // led Gris
        break;
      case 8: // Mesure Courant PC
        Blynk.virtualWrite(V7, data[2].toFloat());
        if (data[2].toFloat() > 0.2) Blynk.setProperty(V7,"color","#23C48E"); // Vert
        else Blynk.setProperty(V7,"color","#999999"); // Gris
        break;
      case 9: // Moyenne tension batterie
        Blynk.virtualWrite(V3, data[2].toFloat());
        break;
      case 10: // Mesure température batterie
        Blynk.virtualWrite(V6, data[2].toFloat());
        break;
      case 11: // Mesure tension alim
        Blynk.virtualWrite(V4, data[2].toFloat());
        break;
      case 12: // Alarme Temperature
        Blynk.setProperty(V6,"color","#D3435C"); // Rouge;
        break;
      case 13: // Pré Alarme Temperature
        Blynk.setProperty(V6,"color","#fb7215"); // Orange;
        break;
      case 14: // Temperature OK
        Blynk.setProperty(V6,"color","#23C48E"); // Vert;
        break;
      case 15: // Alarme Tension Batteries
        Blynk.setProperty(V3,"color","#D3435C"); // Rouge;
        break;
      case 16: // Pré Alarme Tension Batteries
        Blynk.setProperty(V3,"color","#fb7215"); // Orange;
        break;
      case 17: // Tension Batteries OK
        Blynk.setProperty(V3,"color","#23C48E"); // Vert;
        break;
      case 18: // Timer avant extinction wifi
        Blynk.virtualWrite(V10, data[2].toInt());
        break;
      case 19: // Timer avant extinction forcée du PC
        Blynk.virtualWrite(V11, data[2].toInt());
        break;
      case 20: // Timer démarrage du PC
        Blynk.virtualWrite(V12, data[2].toInt());
        break;
      default:
        terminal.print(F("Erreur Switch I"));
        terminal.println();
        break;
      }
    }
    else if (data[0] == "M")
    {
      terminal.print(F("Message reçu: "));
      switch (data[1].toInt())
      {
        case 1: // Problème démarrage PC
          terminal.print(F("Problème démarrage PC"));
          terminal.println();
          break;
        case 2: // PC démarré
          terminal.print(F("PC démarré"));
          terminal.println();
          break;
        case 3: // Allumage du PC en cours
          terminal.print(F("Allumage du PC en cours"));
          terminal.println();
          break;
        case 4: // Reset du PC en cours
          terminal.print(F("Reset du PC en cours"));
          terminal.println();
          break;
        case 5: // Synchro et Extinction du PC en cours
          terminal.print(F("Synchro et Extinction du PC en cours"));
          terminal.println();
          break;
        case 6: // Extinction du PC en cours
          terminal.print(F("Extinction du PC en cours"));
          terminal.println();
          break;
        case 7:
          break;

        default:
          terminal.print(F("Erreur Switch M"));
          terminal.println();
          break;  
      }
    }
    terminal.flush();
    // on vide la chaine pour utiliser les messages suivants
    inputString = "";           
    stringComplete = false;
  }
}

Photo pour présenter le projet :

Merci pour votre aide, je sèche complètement et devient complètement :crazy_face:

Schéma : un schéma soigneux à main levée peut faire l'affaire.
Chacun a son logiciel de schéma préféré !!
sans installation : EasyEDA est à tester (très grand nombre de symboles et empreintes apportés par la communauté.)

Carte D1MIni seule , le réveilde deep-sleep se produit-il bien en mettant brièvement RST à la masse ?

Remarque : En reliant directement la sortie D3 (niveau Haut 5V) à l'entrée Reset d'une ESP8266 (niveau haut 3,3V ) on risque d'endommager ce dernier qui, selon Espressif fabricant des ESP8266 n'est pas "tolérant au 5V" sur ses GPIO. (cf Data Sheet ESP8266)
Chacun fait ce qu'il veut des ses ESP8266, il faut juste être conscient du risque !

Une solution simple dans ce cas particulier : insérer une diode (cathode vers D3 /Pro Micro) , anode vers RST/ESP8266) . Quand D3 est à 5V elle sera bloquée et l'ESP8266 ne recevra pas 5V, quand D3/ Pro Micro est à l'état BAS elle sera passante et mettra environ 0,7V sur l'entrée RST /ESP8266

Coode ESP8266 : le deepsleep parait correctement appelé avec en paramètre une valeur qui n'autorise que le réveil par Reset

Pour information sur les cartes D1 MIni une résistance de pull-up de 12K Ohm est placée sur l'entrée RST, pull-up vers 3,3V pas vers 5V.

Désolé, je n'ai pas précisé, mais la carte Pro micro est une version 3.3v 8Mhz.
Oui, la carte Wemos se réveil bien quand je met directement l'entrée RST à la masse.

OK pour la carte Pro Micro 3V3

-Sortie D3 endommagée ? comment se comporte-telle en soririe en l'absence d eliaison avec la carte D1 Mini ?

l'alimentation est la même pour les deux cartes.
bornes 5V reliées ensemble ?

-3 liaisons seulement entre Pro Micro et D1 Mini (alimentation et D3-RST) ?

Schématique : je ne sais rien d'Eagle depuis son rachat par Autodesk
S'il ya un blocage complet pour Kicad, essayer DipTrace (Windows ou MacOs), sa partie schématique m'avait paru assez maniable

Je me suis également posé cette question. En déconnectant la carte wemos, la sortie D3 passe bien de 3.3V à 0V. J'ai également testé avec une autre carte Pro micro, et le résultat est identique.
Je viens de tester avec une autre carte Wemos, et toujours pareil :sob:

Je ne comprends toujours pas pourquoi ca ne fonctionne pas, mais la solution est là :
https://stackoverflow.com/questions/39481196/how-to-wake-esp8266-from-deep-sleep-without-continuous-resets

Perso, je fait le lien entre D0 et RST sans diode, et je ne raccorde pas D2.
Merci :+1:

Bonjour @ben49460

Au 9ème message on découvre que le D0 de l'ESP8266 est relié à RST :hot_face:

Un schéma à main levée du monrage réel complet aurait évité une perte de temps

Perso : en général je décroche des fils de discussions où le demandeur d'aide 'ballade' les aidants en lâchant peu à peu les données du problème

  1. Quel est l'intérêt de cette liaison D0-RST (avec ou sans diode) si le réveil de ESP8266 ne doit être déclenché que par une impulsion sur RST (implusion produite à l'extérieur de la carte D1 Mini)?
    D0 est la sortie d'un Timer qui permet , si on le souhaite , de réveiller un ESP8266 en sommeil profond au bout du laps de temps choisi. TU ne dis pas vouloir faire cela et ton code ne le fais pas.

  2. Il me semble que pendant le deep-sleep D0 soit ,de fait, une sortie à l'état haut et que la liaison directe (inutile) avec RST soit par contre responsable des 2,6V constatés sur RST. -> Supprimes carrément cette laision
    (ou mets la diode si tu y tiens)

Tu t'es inspiré d'un montage assez spécial ........et inutilement complexe pour l'usage que tu décris,....d'autant plus que les deux cartes fonctionnent sous 3,3V

Bonjour @al1fch ,
Merci énormément pour ton aide, je comprends maintenant pourquoi ça ne fonctionnait pas.
Je vais retirer la liaison D0 - RST.