Mémoire Previous State

**BlueWolf9** · 09/01/2013, 11h15

Bonjour,

Pour mon projet, je suis sensée créer une mémoire puis utiliser les données qui y sont stockées pour faire un conversion.

La mémoire que je dois construire est un buffer circulaire avec une taille de 10.
Ce buffer est créé et le rebouclage se fait sans souci. Par contre pour la conversion je faire un calcul sous la forme :
(a)k = (a)k-1 + (b)k k étant la position actuelle de la mémoire.

Pour l'utilisation des données dans la mémoire j'utilise un compteur.

Je ne vois pas comment je pourrais coder le k-1. J'ai peur que si je code directement k-1 je me retrouve avec la valeur de k soustraite de 1. Ce qui n'est pas ce que je veux.

**mith06** · 09/01/2013, 12h52

Salut,

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
#define BUFF_SIZE 10
int decrement_k(const int k)
{
    return k<=0?BUFF_SIZE-1:k-1;
}

J’espère que çà répond a ta question.

**BlueWolf9** · 09/01/2013, 13h13

Que signifie le "return k<=0?BUFF_SIZE-1:k-1;" ?
Je connais le principe du return mais je ne comprend l'action que va avoir cette ligne.

**transgohan** · 09/01/2013, 13h28

C'est une opération ternaire.
Si k est inférieur ou égal à 0 alors on fait BUFF_SIZE-1 sinon on fait k-1

Autrement codé :

Code C :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
if( k<=0 )
  return BUFF_SIZE-1;
else
  return k-1;

**Neckara** · 09/01/2013, 13h29

Il s'agit de l'opérateur ternaire.

condition ? valeur si condition vrai : valeur si condition fausse.

Exemple : x == 1 ? 1 : 2
=> vaut 1 si x vaut 1 sinon vaut 2.

**BlueWolf9** · 09/01/2013, 13h47

Je gère la mémoire de cette manière-ci :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
 
//ecriture memoire roue 1 et test memoire pleine wheel1 ------------------
 
if (write_buffer_wheel1 != buffer_lenght) {
 
    if (write_buffer_wheel1< buffer_lenght && buffer_full1 != 0)  {           //test de la taille de la memoire
              wheel1 [write_buffer_wheel1]= receive_data[1] + (256*receive_data[0]) ;      //ecriture dans la memoire
              write_buffer_wheel1 ++;                   //incrementation du compteur ecriture                       
    } else if (write_buffer_wheel1< buffer_lenght && buffer_full1 == 0) {
 
         PORTB =0b00000001  ; 
         sendOnCanFull ()   ;
     }
}else {
             write_buffer_wheel1 = 0;                  //rebouclage de la memoire
              wheel1 [write_buffer_wheel1]= receive_data[1] + (256*receive_data[0]) ; 
 
          }
void interrupt 8 TOC0_ISR () {          //lecture de la mémoire
 
  TFLG1 = TFLG1_C0F_MASK ;    // rabaisse le flag de l'interruption
 
 // buffer_empty1 = buffer_lenght - buffer_full1;
 
 if (buffer_empty1 == buffer_lenght) {
    PORTB =0b00000100  ; 
     sendOnCanEmpty ()   ;  
 
 }
 
  if ( read_buffer_wheel1 < buffer_lenght ){                    //test taille de la memoire
 
     TC0 = TC0 + wheel1[read_buffer_wheel1] ;                //lecture des donnees
     read_buffer_wheel1 ++    ;         //incrementation compteur lecture 
      } else{
 
         read_buffer_wheel1 = 0    ;                           //rebouclage memoire   .
         TC0 = TC0 + wheel1[read_buffer_wheel1] ;                //lecture des donnees 
 
     }                                                            
 
}

Je veux faire la conversion juste avant de transmettre les données (en gros avant la ligne TC0=TC0...) Si je touche au compteur (k = read_buffer_wheel1) en faisant une décrementation ça ne risque pas de perturber la suite du programme ?

En bref la mémoire se remplit et se vide non stop est-ce que faire une décrémentation ne va pas perturber la lecture ?

**pfeuh** · 09/01/2013, 14h29

Salut,

Envoyé par BlueWolf9

un calcul sous la forme :
(a)k = (a)k-1 + (b)k k étant la position actuelle de la mémoire.

C'est une somme que tu veux faire? A travers un buffer parce que les données sont envoyées par un autre processus?

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
#include <stdio.h>
#include <stdlib.h>
 
#define BUFFER_SIZE 10
 
typedef struct
{
    float buffer[BUFFER_SIZE];
    int inptr;
    int outptr;
} BUFFER;
 
BUFFER* bufferCreate(void)
{
    BUFFER* pBuffer = malloc(sizeof(BUFFER));
    if(pBuffer != NULL)
    {
        pBuffer->inptr = 0;
        pBuffer->outptr = 0;
    }
    return pBuffer;
}
 
void bufferDestroy(BUFFER* pbuf)
{
    if(pbuf != NULL)
        free(pbuf);
}
 
void bufferPut(float value, BUFFER* pbuf)
{
    pbuf->buffer[pbuf->inptr] = value;
    pbuf->inptr = (pbuf->inptr + 1) % BUFFER_SIZE;
}
 
float bufferGet(BUFFER* pbuf)
{
    float value;
    while(pbuf->outptr == pbuf->inptr)
        /* do nothing, just wait */;
    value = pbuf->buffer[pbuf->outptr];
    pbuf->outptr = (pbuf->outptr +1) % BUFFER_SIZE;
    return value;
}
 
int main(void)
{
	float input[]={1.0, 2.0, 3.0, 4.0, 5.0, 5.0, 5.0, 5.0, 5.0, 5.0 ,5.0, 5.0, 5.0, 5.0, 5.0 };
    int index;
    float value;
    float total;
	BUFFER* pbuf = bufferCreate();
 
	if(pbuf != NULL)
    {
        for(index = 0; index < 15; index++)
        {
            value = input[index];
            total += value;
            bufferPut(total, pbuf);
            printf("%f\n", bufferGet(pbuf));
        }
    }
    bufferDestroy(pbuf);
	return 0;
}

L'idée étant de calculer une somme de deux itérations, il faut une variable supplémentaire qui fait office de somme, ici c'est total. Reculer et ré-avancer avec l'index me semble une mauvaise idée.

A+

Pfeuh

A+

Pfeuh

**BlueWolf9** · 09/01/2013, 14h45

Là où ça devient compliquer c'est que je ne peux pas utiliser de fonction "malloc, free..." et je ne crois pas que return soit supporté par le logiciel que j'utilise (CodeWarrior une très vieille version)

Est-ce que je pourrais utiliser un deuxième compteur en parallèle (par rapport au read_buffer_wheel1) que je resynchroniserai avec le premier après chaque conversion ?

**BlueWolf9** · 09/01/2013, 14h59

Quelque chose comme ça :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
 
 
void convert () {
 
unsigned short decrement;
unsigned short t [10];
unsigned short conv;
unsigned short Delta_t;
 
decrement = read_buffer_wheel1;
decrement --;
 
conv = t[decrement];
 
Delta_t = wheel1[read_buffer_wheel1] - t[decrement];
 
//Output
}

**pfeuh** · 09/01/2013, 15h41

Envoyé par BlueWolf9

Là où ça devient compliquer c'est que je ne peux pas utiliser de fonction "malloc, free..." et je ne crois pas que return soit supporté par le logiciel que j'utilise (CodeWarrior une très vieille version)

Euh... C'est quand même du C que tu nous a montré, j'ai du mal à croire que l'on puisse faire du C sans return! Si j'ai bien compris wikipedia, CodeWarrior est un IDE, il y a quand mêle un compilo C quelque part dedans?

Il me manque beaucoup d'info pour comprendre ce que tu veux faire, mais supposons que tu ne puisses écrire qu'une fonction qui ne retourne rien et que wheel1 et read_buffer_wheel1 soient une sorte de variables globales, tu peux peut-être passer par une variable statique:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
void convert(void)
{
    unsigned short Delta_t;
    unsigned short current_time;
    static unsigned short last_timestamp = 0;
 
    current_time = wheel1[read_buffer_wheel1];
    Delta_t = current_time - last_timestamp;
    last_timestamp = current_time;
    /* Output */
}

**BlueWolf9** · 09/01/2013, 15h52

J'ai oublié de replacer le contexte. En fait j'ai modfié le calcul du début (désolé je ne m'en suis pas rendu compte

)
En gros dans ce que j'ai présenté

(a)k = (a)k-1 + (b)k

b = Delta_t le résultat de ma conversion
a = Wheel1 elle représente les valeurs qui se trouvent dans ma mémoire

Par rapport l'exemple que tu m'as montré, last_timestamp ne peut pas être égal à 0 (sauf au moment de l'init). Il doir prendre la valeur précédente de Wheel1.

**BlueWolf9** · 09/01/2013, 16h00

En bref

Le calcul serai plus :

(b)k = (a)k - (a)k-1
Delta_t = Wheel1[read_buffer_wheel1] - wheel1[read_buffer_wheel1 -1] (avec -1 previous state)

**Bktero** · 09/01/2013, 21h30

Là où ça devient compliquer c'est que je ne peux pas utiliser de fonction "malloc, free..." et je ne crois pas que return soit supporté par le logiciel que j'utilise (CodeWarrior une très vieille version)

Sûrement parce que tu ne codes pas sur PC mais sur micro-contrôleur (d'où l'utilisation de CodeWarrior ?) et que donc pas de gestionnaire de mémoire signifie de de malloc / free ?

**pfeuh** · 10/01/2013, 08h18

Envoyé par BlueWolf9

Par rapport l'exemple que tu m'as montré, last_timestamp ne peut pas être égal à 0 (sauf au moment de l'init).

C'est exactement ce que fait la variable statique de mon exemple... C'est comme une globale, mais en plus propre...

**BlueWolf9** · 10/01/2013, 09h46

Ok je n'avais pas compris ça comme ça.

Et oui je programme bien sur microcontrôleur mais j'ai estimé que mon problème correspondait à du C qu'a du microcontrôleur.

**Bktero** · 10/01/2013, 17h55

Quand tu poses des questions sur le forum C (ça marche pour tous les forums de Developpez.com en fait), n'hésites pas à dire avec quel outil tu travailles (compilateur, type d'architecture, système d'exploitation), ça aide souvent à mieux répondre.

Ici, les gens posent à 90% des questions pour des problèmes en C sous Windows ou Linux. Si tu as un contexte très différent, comme un micro-contrôleur 8 bits, ça peut être particulièrement bon de le préciser car cela implique beaucoup de contraintes sur le code. Tu verras avec le temps ^^

Mémoire Previous State

C

Discussions similaires

Partager

Partager