Elektor Electronics 2018 03 04

On trouve ici deux particularités importantes. D’abord la section
(vide ici) .bss, dont l’absence fait que, même si le processeur
ULP trouve le fichier, il refuse sans commentaire de l’exécuter.
Ensuite, nous avons une séquence qui crée une variable globale
partagée entre l’ULP et Xtensa. Nous pouvons alors poursuivre
avec le code effectif :
entry:
/* Code goes into .text section */
.text
.global entry
move r3, acti_count
ld r0, r3, 0
add r0, r0, 1
st r0, r3, 0
Les processeurs ULP sont des machines à 16 bits. À la
lecture, une partie du registre n’est pas prise en compte. Pour
commencer, nous décalons l’adresse de acti_count dans le
demi-registre R3, que nous utilisons pour lire la valeur. Celle-ci
est incrémentée avec add et réécrite dans acti-count.
Pour finir, nous réveillons le côté Xtensa. Ici, nous avons une
petite diffculté : les commandes de réveil ne sont acceptées
qu’une fois que le noyau a été arrêté avec succès. C’est pourquoi
notre code n’exécute wake que lorsque le SOC (système sur
puce) a confirmé sa mise en sommeil dans le registre concerné :
de l’ULP du côté C.
Ici, la situation exige une réflexion approfondie. La partie
Xtensa du microcontrôleur contient une quantité de registres
dont la préservation du contenu exige une dépense d’énergie
considérable. Pour minimiser cette dépense, Espressif coupe
l’alimentation des registres, ce qui entraîne malheureusement la
perte de leur contenu. La première action de notre programme
est donc de déterminer la cause du réveil :
void app_main() {
//Init check
esp_sleep_wakeup_cause_t cause =
esp_sleep_get_wakeup_cause();
if (cause != ESP_SLEEP_WAKEUP_ULP) {
printf("Clean boot\n");
init_ulp_program();
} else {
printf("Start caused by ULP\n");
printf("Counter %u \n", ulp_acti_count &
UINT16_MAX);
}
Il est important ici de masquer le contenu de ulp_acti_
count qui, comme tous les registres de Xtensa, a une largeur
de 32 bits. Comme l’ULP ne peut écrire que dans les seize
premiers, il faut masquer le reste qui est « indéfini ».
exit:
halt
/* 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
halt
Côté C
Ensuite, nous retournons au programme hello_world_main.c
dans lequel nous incluons quelques fichiers d’en-tête :
#include "esp_sleep.h"
#include "nvs.h"
#include "nvs_flash.h"
#include "soc/rtc_cntl_reg.h"
#include "soc/rtc_io_reg.h"
#include "soc/sens_reg.h"
#include "soc/soc.h"
#include "driver/gpio.h"
#include "driver/rtc_io.h"
#include "esp32/ulp.h"
#include "ulp_main.h"
ulp_main est créé par Makefile : le fichier prépare les contenus
nécessaires au traitement ou au dialogue avec le programme
Trop compliqué !
Si l’on rechigne à travailler au niveau de make (ou si l’on a
affaire à de très vieux exemples de code), on peut utiliser les
macros (mais elles ont depuis été abandonnées par Espressif).
Dans ce cas, un programme ULP est produit à partir d’un
tableau d’instructions :
const ulp_insn_t program[] = {
I_MOVI(R3, 16),
I_LD(R0, R3, 0),
I_LD(R1, R3, 1),
I_ADDR(R2, R0, R1),
I_ST(R2, R3, 2),
I_HALT()
};
La suite est constituée d’une séquence de code C plus ou
moins standard qui calcule la taille du programme en instructions
et fournit le résultat pour exécution. Il faut prendre
garde à toujours faire le calcul de size comme indiqué cidessous
– certaines macros sont interprétées par deux instructions
séparées :
size_t load_addr = 0;
size_t size = sizeof(program)/sizeof(ulp_insn_t);
ulp_process_macros_and_load(load_addr, program,
&size);
ulp_run(load_addr);
www.elektormagazine.fr mars/avril 2018 35