Elektor Electronics 2018 03 04

. . .
Figure 6. Ici, il manque un module...
Si l’on essaie de compiler notre programme dans son état
précédent, on obtient le message d’erreur de la figure 6
parce que les composants téléchargés « normalement » ne
contiennent pas, au moment de la publication de cet article,
les modules nécessaires.
Accédez au portail sous [9] et téléchargez le fichier correspondant
à votre configuration. Extrayez l’archive vers /esp et ajoutez-la
au chemin :
tamhan@TAMHAN14:~/esp$ ls
esp32ulp-elf-binutils esp-idf hello_world
xtensa-esp32-elf
tamhan@TAMHAN14:~/esp$ export PATH="$PATH:$HOME/esp/
esp32ulp-elf-binutils/bin"
Retournez ensuite à make menuconfig et activez l’option
Component Config-Y ESP32-Specific Enable Ultra Low Power
(ULP) Coprocessor. Make menuconfig insère alors (512) RTC
slow memory reserved for coprocessor. Cette allocation de
mémoire sera conservée.
Figure 7. Liste des broches accessibles par l’ULP. (Source : Espressif [7])
La mise en sommeil s’effectue en deux étapes. D’abord, nous
ordonnons à la logique de gestion de l’alimentation de prendre
en compte les commandes de réveil émanant de l’ULP, ensuite,
nous démarrons le programme ULP et mettons le processeur
principal au lit :
}
//Good night
ESP_ERROR_CHECK( esp_sleep_enable_ulp_wakeup() );
ESP_ERROR_CHECK( ulp_run((&ulp_entry - RTC_SLOW_
MEM) / sizeof(uint32_t)));
esp_deep_sleep_start();
L’initialisation du programme ULP s’effectue aussi en plusieurs
étapes. On commence par inclure deux constantes produites
par makefile. Ensuite on appelle ulp_load_binary pour charger
les ressources :
extern const uint8_t ulp_main_bin_start[]
asm("_binary_ulp_main_bin_start");
extern const uint8_t ulp_main_bin_end[]
asm("_binary_ulp_main_bin_end");
void init_ulp_program()
{
esp_err_t err = ulp_load_binary(0, ulp_main_bin_
start, (ulp_main_bin_end - ulp_main_bin_start) /
sizeof(uint32_t));
ESP_ERROR_CHECK(err);
Marche – Arrêt !
Si l’on exécute le programme dans l’état précédent, on constate
que le compteur est incrémenté de 3. Cela provient du fait que
le délai court dès l’appel de ulp_run et qu’il faut du temps pour
mettre le processeur principal en sommeil. Les commandes de
réveil arrivant trop tôt sont ignorées et l’ULP s’enferme dans
une espèce de boucle infinie, le temps de trois incrémentations.
Pour régler ce problème, il sufft, lorsqu’on constate le nonendormissement,
de sauter vers le haut dans une boucle de
veille « active » :
exit:
/* Check if the SoC has said INRI already */
READ_RTC_REG(RTC_CNTL_DIAG0_REG, 19, 1)
and r0, r0, 1
jump exit, eq
wake
WRITE_RTC_FIELD(RTC_CNTL_STATE0_REG, RTC_CNTL_
ULP_CP_SLP_TIMER_EN, 0)
halt
Pour l’auteur, le désir de mesurer le temps de mise en sommeil
de la MCU était irrésistible. Quelques broches GPIO de l’ESP32
sont des hybrides, qui peuvent être commandées aussi bien
par le module RTC que par le processeur principal ; le tableau
en figure 7 donne la correspondance.
L’initialisation de ces broches s’effectue par une interface de
programmation spéciale, qui se distingue par le préfixe RTC.
Notez que les broches GPIO spécifiées ici (du côté ESP32) le
sont par leur désignation ESP32 :
void init_ulp_program() { . . .
ulp_acti_count=0;
rtc_gpio_init(cpu_num);
36 mars/avril 2018 www.elektormagazine.fr