écrire des données à enregistrer

j'ai l'adresse de la mémoire de certains de registre(l'adresse LCDCW1 est C000).

codes c:

#define LCDCW1 0xC000

*LCDCW1=0x31;

je veux juste écrire des données de ce registre. Les codes ont des problèmes, comment le corriger?

thx!

quel compilateur / plate-forme?
8051, compilateur:ICC8051
Le code est ne compile pas car 0xc000 n'est pas un pointeur, et le * opérateur nécessite un pointeur opérande.

OriginalL'auteur martin | 2010-04-16

  1. 18

    Vous pouvez, comme d'autres l'ont suggéré, déclarer approprié pointeur, c'est à dire,

    volatile uint32_t *reg = (volatile uint32_t *)0xc000;

    Notez que j'ai ajouté le volatile qualificatif. C'est toujours une bonne idée lors de la lecture ou de l'écriture des registres du matériel, car il garantit que chaque accès que vous effectuez dans votre code C montre, en réalité, dans le code généré.

    Cependant, habituellement, je préfère écrire des macros comme ce

    #define READ_LCDCW1() ...
#define WRITE_LCDCW1(value) ...

    puis remplissez ces appropriées gcc smo. J'aime ces mieux que d'utiliser directement les pointeurs car:

    • Je pense qu'ils lisent mieux dans le code, l'identification de ce que je fais, la lecture d'un registre, au lieu de se concentrer sur la façon dont je le fais.
    • Certains requièrent un processus multi-étape de lecture du matériel. Ce qui est caché facilement dans les macros de ce style, et la majeure partie de mon code fait toujours référence à des registres qui m'intéresse, pas la complexité de la façon dont le matériel me fait de les toucher.
    • Enfin, en utilisant asms, je sais exactement comment je suis accéder au registre. Parfois il y a des instructions spéciales ou des espaces d'adressage nécessaires pour arriver à un registre, qui ne peuvent généralement pas être généré par le compilateur C.
    • Même si vous êtes en désaccord avec la motivation pour l'utilisation de l'asm déclarations, je serais encore suggèrent d'emballage de votre registre accède à des macros (ou fonctions inline).

    Dans votre cas, le plus simple des définitions devraient être:

    #define LCDCW1_ADDR       0xc000
#define READ_LCDCW1()     (*(volatile uint32_t *)LCDCW1_ADDR)
#define WRITE_LCDCW1(val) ((*(volatile uint32_t *)LCDCW1_ADDR) = (val))
    +1 pour le (et trop souvent négligé) utilisation de "volatile".
    Voir @Schedler de commentaire ci-dessous pour un document intéressant sur la façon dont la plupart des compilateurs ne parviennent pas à mettre en œuvre volatile correctement dans diverses délicate cas.
    N'utilisez uint32_t etc au lieu de long.
    Tout à fait raison. J'ai édité la réponse appropriée.
    Yep, Atmel livre blanc est d'accord avec vous, mot pour mot, atmel.com/images/doc8075.pdf, page 9.

    OriginalL'auteur Dale Hagglund

  2. 4

    Je crois un mot de prudence sur l'utilisation du mot clé volatile est dans l'ordre.

    Parfois (souvent) que le compilateur moyen volatil n'est pas ce que le programmeur a prévu (et vice versa). Il est de bonne pratique de toujours vérifier les code machine lorsque le mot clé volatile est utilisé, afin d'éviter les mauvaises surprises.

    Pour plus de références, voir, par exemple, http://www.cs.utah.edu/~regehr/documents/emsoft08-preprint.pdf

    C'est un très bon papier. Sa technique proposée pour faire volatils fonctionner de manière fiable dans les compilateurs C sont intéressants, mais je pense qu'ils sont pire d'un point de vue de la lisibilité que de simplement fournir une paire lecture/écriture de macros de fonctions pour chaque registre, comme je le suggère dans ma réponse à ce post.

    OriginalL'auteur Schedler

  3. 1

    LCDCW1 est juste une valeur entière. Vous ne pouvez pas faire *. Vous devez le convertir en entier (ou type vous avez besoin de pointeur et de l'utiliser ensuite. Par exemple:
    *(int*)LCDCW1=0x31;

    N'utilisez uint16_t etc au lieu de int.

    OriginalL'auteur Naveen

  4. 1

    En supposant que vous inscrire a la même taille qu'un long:

    volatile long * ldccw1 = (long*)0xc000;

*lcdcw1 = myValue;
    ma solution est tout à fait le même, mais il y a une erreur: pointeur expression nécessaire, u ne savez-vous pourquoi?
    Vous pouvez poster votre code qui donne une erreur?
    Les pointeurs externes registres doivent être volatile qualifié.
    Naveen de répondre, en donne l'explication: vous avez besoin de jeter votre valeur de nombre entier à un pointeur de type.
    d'accord, ma réponse est modifié en conséquence.

    OriginalL'auteur mouviciel

  5. 0

    Je ne sais pas ce LCDCW1 moyens, mais pour écrire à une constante adresse:

    *(int*)0xC000 = 42;

    Adapter à (votre registre ne peuvent pas être de type int taille).

    OriginalL'auteur Marcelo Cantos