portOutputRegister retourne un octet "virtual"

International Français
1

Bonjour à tous,

J'avais ce petit extrait qui fonctionne:

uint8_t *port;

void setup()
{
  port=portOutputRegister(digitalPinToPort(5));
}

void loop() {}

Port me permet d'accéder aux registre, ce qui me permet de pouvoir faire du PWM avec mes paramètres personnels. Depuis peu, j'ai un avertissement car portOutputRegister retourne un entier volatile et pas un entier. Sa définition:

#define portOutputRegister(P) ( (volatile uint8_t *)( pgm_read_word( port_to_output_PGM + (P))) )

Pourquoi retourner un entier volatile?

Pour m'en sortir, j'ai écris avec un transtypage:

uint8_t *port;

void setup()
{
  port=(uint8_t*)portOutputRegister(digitalPinToPort(5));
}

void loop() {}

Est-ce une bonne idée?

2

C’est pas un entier mais ça retourne un pointeur vers un registre de sortie pour un port spécifique.

➜ volatile informe le compilateur que ce registre est susceptible de changer de manière imprévisible (un changement matériel ou une interruption) et qu’il doit toujours être lu directement à partir de la mémoire chaque fois qu’il est accédé.

Donc vous risquez d’être victime d’une optimisation du compilateur qui mettrait en cache la valeur

3

Cela voudrait dire que su P est volatile, pgm_read_word( port_to_output_PGM + (P)) pourrait être en cache?
Dans ce cas si compteur est une variable volatile compteur+1 ne le serait pas?

4

Oui, seule la lecture de compteur est volatile, pas le résultat de compteur + 1.

Pour l’autre expression, c’est Un pointeur volatile donc il garantit que l’adresse pointée est lue ou écrite directement en mémoire à chaque accès, tandis qu’un pointeur non volatile peut être optimisé par le compilateur, qui peut stocker temporairement la valeur.

Le type (volatile uint8_t *) signifie que le pointeur pointe vers un octet volatile. Les 4 options

uint8_t * : Le pointeur et la valeur pointée ne sont pas volatiles.

volatile uint8_t * : La valeur pointée est volatile, mais pas le pointeur.

uint8_t * volatile : Le pointeur est volatile, mais pas la valeur pointée.

volatile uint8_t * volatile : Le pointeur et la valeur pointée sont tous deux volatiles.

5

Je me suis mal exprimé. Si compteur est une variable volatile et que j'écris valeur = compteur; le compilateur refera forcément le transfert. Mais si si j'écris valeur = compteur+1; je pensais que le compilateur serait obligé de recalculer la somme. Ce qui voudrait dire que si P est volatile, et que l'on ait:

#define portOutputRegister(P) ( (uint8_t *)( pgm_read_word( port_to_output_PGM + (P))) )

le compilateur devrait relire la valeur systématiquement. Ce ne serait pas le cas?

Finalement ce n'est pas grave de faire le premier transtypage en volatile et le second en non volatile.

6

Oui si compteur est volatile alors valeur sera calculée en allant lire le compteur et valeur ensuite n’est pas volatile.

Mais dans votre cas vous obtenez un pointeur vers une valeur volatile, c’est différent car vous ne voulez pas que le compilateur cache la valeur pointée , vous voulez aller lire à chaque accès à la valeur pointée.