J’ai besoin d’aide, j’ai cherché sur le net une réponse à ma question et je n’ai rien trouvé hélas
Je cherche à utiliser un ESP32 pour sa capacité à consommer très très peu en deep sleep mode.
Je souhaite le réveiller par un timer, vérifier le voltage de la batterie d’alimentation et si elle est faible il m’envoie un e-mail. Ça, ça fonctionne bien.
J’ai écrit un bout de code (toujours avec une aide très précieuse des exemples installés dans l’IDE) qui permet aussi de réveiller l’esp32 par un pull up sur n’importe laquelle des pins (7) qui devraient être connectées à mon clavier. En réalisant un clavier avec 12 boutons poussoirs et 8 fils (l’un des fils est le vcc) la saisie des touches est bien détectée.
Note: J’ai ouvert hier un fil qui ressemble à celui-ci que je voudrais uniquement consacrer au debug de la non prise en compte de définitions gpio
J’ai écrit du code qui permet de voir si une touche a été saisie sur un clavier matriciel 4x3, concatener les touches qui ont été saisies et après une pression sur une touche pour valider (#) le code vérifie si le « mot de passe » est bon, si oui j’active quelques secondes un relai qui permet d’ouvrir un coffre fort. Sans sleep mode ça fonctionne très bien. ( Librarie Keypad)
Là où ça se corse c’est quand je desire conjuguer le deep sleep mode et la saisie d’un « mot de passe » sur le clavier.
Je tiens à préciser que j’arrive à le faire fonctionner sur un arduino mini pro avec l’utilisation de pas mal de modifications dans la bibliothèque keypad.
Est-ce que l’un de vous a déjà réalisé une application similaire sur esp32 ?
Existe-t’il une librairie « clavier » qui fonctionne avec le « deep sleep » ou il faut que je m’en fasse une ?
Ce redémarrage 'total' au réveil et le temps que ça prend rend problématique le traitement clavier matriciel en cas d'appui bref sur une touche. Sur un appui de plusieurs secondes ça peut peut être passer
(On n'est pas dans la situation d'une reprise immédiate d'activité au réveil, là où elle s'était arrêtée comme dans le cas des AVR)
SI le clavier matriciel est impératif il me semble qu'il faut déléguer son traitement à un petit microcontrolleur annexe ou à un circuit intégré spécialisé (74C922 ou 74C923)
Merci, savez-vous dans quel répertoires se trouvent les fichiers du sdk ?
Pour le principe de la libraire keypad avec le deep sleep, je pense avoir bien saisi le concept. J’avais déjà écrit quelques lignes de code pour y arriver avec l’arduino mini pro et le code fonctionne.
J’ai fait les mêmes modifications avec les fonctions rtc pour l’esp32 et l’application soit ne fait que rebooter soit ne fonctionne pas, je perds du temps dans le déboggage, j’étais donc curieux de savoir si quelqu’un d’autre avait déjà réalisé avec succès cette opération
De mémoire, donc je peux éventuellement confondre avec un autre CPU, il me semble que la sortie du deepsleep ne fonctionne pas avec toutes les pins il n'y en a que quelques unes qui peuvent être utilisées. Et il me semble aussi qu'il faut spécifier de laisser les pullup actifs
Merci de vos messages, grâce aux exemples et commentaires de ceux-ci j’ai pu tester assez facilement le réveil d’un esp32 en deep sleep par plusieurs touches.
Grace à la fonction esp_sleep_get_wakeup_cause() on sait ce qui a sorti l’esp32 du deep sleep
Grâce à la fonction esp_sleep_get_ext1_wakeup_status() on sait quel gpio ou combinaison de gpio ont changé d’état.
Grace à ça il est facile de réaliser un clavier avec des poussoirs qui peuvent faire un pull-up de deux gpio en même temps donc de savoir quelle touche rang / colonne a été activée.
Dans mon cas, avec un clavier 8 fils pour un 4x3 ça fonctionne très bien:
void setup()
{
Serial.begin(115200);
delay(1000); //Take some time to open up the Serial Monitor
// Increment boot number and print it every reboot
++bootCount;
Serial.println();
Serial.println("Safe lock system v2, 7 nov 2024");
Serial.println("===============================");
Serial.println("Boot number: " + String(bootCount));
// Print the wakeup reason for ESP32
print_wakeup_reason();
if(wakeup_reason==ESP_SLEEP_WAKEUP_TIMER)
{
if (getBatteryVoltage() < BATT_VOLTAGE_LOW)
sendBatteryLowMessage();
}
else // Keyboard interrupt
{
uint64_t GPIO_reason = esp_sleep_get_ext1_wakeup_status();
Serial.print("KEY that triggered the wake up: ");
switch(GPIO_reason)
{
case GPIO_SEL_13 | GPIO_SEL_27: Serial.println("1"); break;
case GPIO_SEL_12 | GPIO_SEL_27: Serial.println("2"); break;
case GPIO_SEL_14 | GPIO_SEL_27: Serial.println("3"); break;
case GPIO_SEL_13 | GPIO_SEL_26: Serial.println("4"); break;
case GPIO_SEL_12 | GPIO_SEL_26: Serial.println("5"); break;
case GPIO_SEL_14 | GPIO_SEL_26: Serial.println("6"); break;
case GPIO_SEL_13 | GPIO_SEL_25: Serial.println("7"); break;
case GPIO_SEL_12 | GPIO_SEL_25: Serial.println("8"); break;
case GPIO_SEL_14 | GPIO_SEL_25: Serial.println("9"); break;
case GPIO_SEL_13 | GPIO_SEL_33: Serial.println("*"); break;
case GPIO_SEL_12 | GPIO_SEL_33: Serial.println("0"); break;
case GPIO_SEL_14 | GPIO_SEL_33: Serial.println("#"); break;
default: Serial.println((log(GPIO_reason))/log(2)); break;
}
}
// Define bitmask for multiple GPIOs
uint64_t bitmask = GPIO_SEL_13 | GPIO_SEL_12 | GPIO_SEL_14 | GPIO_SEL_27 | GPIO_SEL_26 | GPIO_SEL_25 | GPIO_SEL_33;
esp_sleep_enable_ext1_wakeup(bitmask, ESP_EXT1_WAKEUP_ANY_HIGH);
rtc_gpio_pulldown_en(GPIO_NUM_13); rtc_gpio_pullup_dis(GPIO_NUM_13);
rtc_gpio_pulldown_en(GPIO_NUM_12); rtc_gpio_pullup_dis(GPIO_NUM_12);
rtc_gpio_pulldown_en(GPIO_NUM_14); rtc_gpio_pullup_dis(GPIO_NUM_14);
rtc_gpio_pulldown_en(GPIO_NUM_27); rtc_gpio_pullup_dis(GPIO_NUM_27);
rtc_gpio_pulldown_en(GPIO_NUM_26); rtc_gpio_pullup_dis(GPIO_NUM_26);
rtc_gpio_pulldown_en(GPIO_NUM_25); rtc_gpio_pullup_dis(GPIO_NUM_25);
rtc_gpio_pulldown_en(GPIO_NUM_33); rtc_gpio_pullup_dis(GPIO_NUM_33);
/*
Second we configure the wake up source
We set our ESP32 to wake up every N seconds
*/
esp_sleep_enable_timer_wakeup(TIME_TO_SLEEP * uS_TO_S_FACTOR);
Serial.println("Setup system to sleep for " + String(TIME_TO_SLEEP) + " Seconds");
//Go to sleep now
Serial.println("Going to sleep now");
esp_deep_sleep_start();
Serial.println("This will never be printed");
}
Le deep sleep du esp32 est plus performant en terme de consommation d’énergie que l’arduino mais au réveil il est plus lent et redémarre par le setup…
Mais de cette façon je ne peux pas utiliser le clavier existant de mon coffre et c’est bien dommage !!
Si je mets mon clavier de test en face avant de mon coffre, même avec un joli boîtier en impression 3D ça restera une verrue hyper moche…
J’ai essayé d’utiliser une des 7 pins du clavier en output, high (row) et une autre en input pulldown mais une pression sur la bonne touche ne réveille pas le proc.
ça se discute.....les ESP32 sont les seuls µC que j'utilise désormais mais auparavant j'ai eu d'excellents résultats (5µA dans mon cas) en mode sleep avec des cartes Arduino Pro Mini 8 MHz 3V3 un peu retouchées comme indiquées ici au Chapître 2 :
En fait j’ai déjà suivi ces conseils auparavant, je pense l’avoir déjà dit dans ce sujet.
Malgré cela, la consommation de mon pro mini en sleep mode est trop élevé et mon accu, pourtant d’une capacité élevée, ne tient pas le coup dans la durée.
Lors de mon développement sur arduino pro mini j’ai posé des questions sur un forum, je ne sais plus lequel et on m’avait conseillé de passer sur un esp32… a l’époque j’avais du faire déjà pas mal de modifications dans la librairie keypad, plus avoir recours à plein de petites astuces, qui ont rendu mon code peu élégant. Ça me gênait mais j’aurais survécu si la consommation ne restait pas trop élevé pour que la batterie puisse durer très longtemps.
Aujourd’hui, j’en ai un peu raz le bol d’avoir à charger mon accu trop régulièrement, et, comme j’ai commencé à utiliser des esp32 pour mon hobby (trains électriques) je m’étais dit que je pouvais essayer de résoudre mon problème de consommation sur mon coffre.
J’ai en premier écrit un bout de code qui se réveille une fois par jour, m’envoie un e-mail avec le voltage mesuré de mon accu et se rendort…. et après plusieurs semaines je n’ai vu aucune chute de tension que je puisse vérifier aussi avec un multimètre qui soit significative. Ça me semblait top… si ce n’est qu’aujourd’hui je n’arrive pas à utiliser un clavier matriciel similaire à celui de mon coffre pour réveiller mon esp32… bon je ne suis pas vraiment un programmeur expérimenté ni un bon en électronique mais je ne suis pas idiot non plus…,
Correction, j’ai donné des informations sur ce que j’avais fait avec le pro mini dans un autre sujet. J’espérais être déjà allé au bout de ce qu’on pouvait faire avec un arduino pour réduire au minimum la consommation sans que ce soit au niveau de mes attentes/espoirs…
Le bout de code qui fait le job est listé au dessus, il faut juste réaliser soi même un clavier matriciel avec des poussoirs avec 2 sorties, le vcc qui arrive en entrée sur les deux autres pattes, elles-même reliées à un gpio distinct…
Je n’ai pas trouvé de clavier comme ça dans le commerce, donc je l’ai fait moi avec un ci trous métallisés des poussoirs trouvés chez Ab et de l’impression 3D
Les touches proviennent d'un claver acheté sur AI, le CI est fixé à son support par 4 petites vis et il est aussi rentré "en force" dans son support... le support sera aussi fixé au coffre par 4 vis qui traverseront la porte, j'ai commandé des mèches spéciales pour percer la porte... des mèches neuves de GSB ne rayent presque pas celle-ci !
