Exemple C de la Fonction en utilisant des variables volatiles

pour un papier, je suis à la recherche d'un de la vie réelle fonction C qui utilise des variables volatiles. Ce qui en soi n'est pas difficile à trouver, mais je suis à la recherche d'une fonction dans laquelle la valeur de la volatilité de la variable doit changer pendant le cadre de l'exécution de la fonction, pour une branche particulière de la fonction d'être atteint. Quelque chose comme ceci:

typedef struct {
    unsigned       :6;
    unsigned FLAG1 :1;
    unsigned FLAG2 :1;
} __attribute__ ((packed)) REGISTER;

volatile REGISTER * io_ = 0x1234;

int write_to_io()
{
    while (io_->FLAG1) {};
    //io_->FLAG1 is now 0

    io_->FLAG2 = 1;

    sleep(10);

    if (io->FLAG1)  
        return 1;  //io->FLAG1 has changed from 0 to 1
    else
        return 0;  //io->FLAG1 has not changed
 }

Il serait suffisant si différents bits de la structure a changé au cours de l'exécution de la fonction, mais mon principal critère est que, pour une certaine direction pour être atteint, la valeur de la volatilité et de la modification de la variable pendant l'exécution de la fonction.

Je serais très reconnaissant pour tous les exemples de la vie réelle. Je n'ai pas été en mesure de trouver de nombreux exemples sur l'utilisation de volatiles sur le web.

InformationsquelleAutor Ham | 2008-12-22

c volatile

2

Voici un exemple de mon professeur, qui a travaillé sans volatile avec un compilateur (lcc), mais breaked quand je le lance avec mon gcc port pour ce processeur. J'ai dû mettre le volatile.
```
static int volatile busTimeoutSeen;

int busTimeoutISR(int irq) {
  busTimeoutSeen = 1;
  return 1;  /* skip offending instruction */
}


int memsize(void) {
  unsigned char volatile *ptr;
  unsigned char b;
  ISR oldService;

  busTimeoutSeen = 0;
  oldService = getISR(16);
  setISR(16, busTimeoutISR);
  ptr = (unsigned char *) 0xC0000000;
  while (1) {
    b = *ptr;
    if (busTimeoutSeen) {
      break;
    }
    ptr += (1 << 12);
  }
  setISR(16, oldService);
  return (ptr - (unsigned char *) 0xC0000000) >> 12;
}
```
Il lit en continu à partir de toutes les pages, jusqu'à ce que nous obtenir au-delà de la dernière page, ce qui provoque une interruption, qui va busTimeoutSeen à 1. Que se passe derrière les coulisses, nous dire au compilateur pour lire et écrire les données toujours à la mémoire.
- Merci beaucoup litb, cet exemple fera très bien l'affaire. Dans la fonction memsize, le busTimeoutSeen a pour changement de 0 pour non-zéro lors de l'exécution de la fonction, pour la fonction à remplir.
InformationsquelleAutor Johannes Schaub - litb

Canoniques (et portable) par exemple est le traitement d'un signal asynchrone. (Vous pouvez probablement fournir de renseignement sur les transmissions à votre programme avec Ctrl-C).

#include <signal.h>
#include <stdio.h>

volatile sig_atomic_t quit;

void signal_handler(int sig)
{
    signal(sig, signal_handler);
    quit = 1;
}

int main(void)
{
    signal(SIGINT, signal_handler);
    puts("Hit return to poll quit flag");
    while (!quit) getchar();
    return 0;
}

InformationsquelleAutor fizzer

3

Choisissez votre favori système d'exploitation open source, et de regarder pour les anciens pilotes de périphérique, vous trouverez quelques-unes qui n'ont pas d'autre façon de travailler.

InformationsquelleAutor mat
0

Mappés en mémoire IO est un exemple où une valeur dans la mémoire peuvent en fait représenter lecture à partir d'un périphérique tel qu'un port COM. Lorsque j'ai appris le C, c'était l'un des exemples sont donnés pour l'utilisation du mot clé volatile.

InformationsquelleAutor Daniel Paull

Vous devez vous connecter pour publier un commentaire.