Ecriture/Lecture d'une adresse memoire

[Daddy75]

Bonjour,

Question basique pour la plupart d'entre vous mais j'aimerais votre confirmation.
J'ai besoin de lire la valeur d'un port et d'ecrire a l'adresse d'un autre sur un microcontroller ARM.
Voici mon code :

Code :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
/* Port address */
#define INPUT_PORT_ADDR      0x40    //Input Port Address - to be defined
#define OUTPUT_PORT_ADDR   0x80  //Output Port Address  - to be defined

void Output_to_keypad(unsigned char output)
{
     unsigned char * KeypadRowPort = (unsigned char *)OUTPUT_PORT_ADDR;
     // Set output to keypad row
    *KeypadRowPort = output;
}

bit_8_e Input_from_keypad(void)
{
    bit_8_e InputKey;

    // Get input from keypad column
    InputKey = * ((bit_8_e *) INPUT_PORT_ADDR);

    return (InputKey);
}

N.B: "bit_8_e" est un typedef enum


Pouvez-vous me confirmer que cela est correct?

[Anouschka]

Salut Daddy,

Tes fonctions sont correctes.

A+

[prgasp77]

Bonjour,
l’absence de l'utilisation du mot clé volatile pourrait te jouer de sales coups, de manière aléatoire.

Code C :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
/* Port address */
#define INPUT_PORT_ADDR      0x40    //Input Port Address - to be defined
#define OUTPUT_PORT_ADDR   0x80  //Output Port Address  - to be defined
 
void Output_to_keypad(unsigned char output)
{
     volatile unsigned char * KeypadRowPort = (volatile unsigned char *)OUTPUT_PORT_ADDR;
     // Set output to keypad row
    *KeypadRowPort = output;
}
 
bit_8_e Input_from_keypad(void)
{
    volatile bit_8_e InputKey;
 
    // Get input from keypad column
    InputKey = * ((volatile bit_8_e *) INPUT_PORT_ADDR);
 
    return (InputKey);
}

Cdlt,

[mith06]

Salut,

Je pense que tu peux aussi déclarer ces méthodes inline.

[Bktero]

Je pense qu'on ne met inline à une fonction que si on a montré que cela était nécessaire avec profiler.

[Anouschka]

@Bktero -> tu peux m'en dire plus sur profiler? Ca semble intéressant comme programme.
Sinon pour rebondir sur le inline, je suis de l'avis de mith06. En effet, ces fonctions comportent très peu d'instructions, donc elles s'exécuteront plus vite en inline (càd que l'appel de la fonction est remplacé par le compilateur par son contenu) que par un appel de fonction "classique", qui va en plus nécessiter une sauvegarde/restauration de la pile et des registres non volatiles, et des instructions de branchement.

[Bktero]

Pour ce qui est du profiling (qu'on réalise avec un profiler) : http://en.wikipedia.org/wiki/Profili...er_programming)

Inline est un mot-clé que le compilateur n'est pas obligé de respecté, s'il juge que cela ne sert à rien de la rendre inline. Il est communément admis qu'on me mettra ce qualificatif à une fonction que si on se rend compte que cette fonction occupe un temps important (avec un profiler justement) et qu'on souhaite l'optimiser. On vérifiera que l'effet est vraiment positif. Le résultat pourrait être contre productif ! Voir la FAQ C++ à ce sujet : http://cpp.developpez.com/faq/cpp/?page=inline

[daniel06600]

Bonjour. Ton code semble correcte dans la théorie. Dans la pratique il peut y avoir un petit soucis avec le compilateur qui va chercher à optimiser ton code et il ne comprendra pas (bien sur) que tu travaille sur des valeurs qui sont des adresses physiques et non pas de simples valeurs qu'il peut traiter dans des registres internes au processeur. Slt.

[monnoliv]

Si tu programmes en ARM (je suppose que c'est un Cortex-M puisque tu parles de Microcontrôleur), je te conseille vivement d'utiliser les librairies CMIS. Ton code sera plus portable et ce genre d'écriture directe de port n'est plus nécessaire:
Ex code:

Code :

1
2
3
4
#define mainLED_BIT       ( 7 )      //LED sur bit7
LPC_GPIO0->DIR |= ( 0x1 << mainLED_BIT );  //Port0.7 en sortie
LPC_GPIO0->MASKED_ACCESS[ ( 1 << mainLED_BIT) ] = ( ulLEDState << mainLED_BIT );  //affecter ulLEDState à LED