Discussion :

[lcoulon]

La fonction ci-dessous me permet d'écrire dans une mémoire EEPROM, une chaine de caractères appelée eeprom_buffer
Il est possible de définir le un nombre de caractères à écrire et l'adresse de départ (en hexa) ou sera écrit ces caractères : ( testé ça fonctionne )

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
static void Eeprom2_save(size_t size, LWORD address_start)
 
{
    int i;
 
	XE2BeginWrite(EEPROM_CONTROL, address_start);
 
    for(i = 0; i < size; ++i) 
		{
    	XE2Write(eeprom_buffer[i]);
    	}
    XE2EndWrite();
}

Je voudrais associer cette fonction dans le programme suivant ( sorte de ring buffer : qui stocke la chaine entree1_event_http dans un tableau de 4 lignes puis écrase la plus ancienne à chaque fois qu'un nouvel évenement se présente )

Code :

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

char entree1_event_http[4][3];

...

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
// Detecte les changements d'états de ETAT_DIN1 :
 
			new_state1 = ETAT_DIN1;
			// Détection d'un changement d'état
  			if (old_state1 != new_state1) 
			{
    			if (new_state1 == 1) 
				{
				// Traitement du front montant
 
				time = GetTimeTick();							// Get time
    			        offtime(&tm_time, time, LOCAL_OFFSET_SECS);		
 
				asctime(&tm_time, event_time_http, 7);					// Met dans event_time_http l'heure au format n°7
 
				// Sauvegarde des évenements dans tableau (tab_entree1_event_http qui contient 4 lignes :
 
				for(i=1;i<4;i++)											// Paramètre qui indique combien il y a de lignes a décaler ( ici 4 )
   				{				
        		         strcpy(entree1_event_http[i-1],entree1_event_http[i]);	// On copie l'element i vers i-1   ( la ligne 4 est copiée sur la ligne 3 , etc ... )	
   				}
 
				strcpy(entree1_event_http[3],etiquette_entree1);			
				sstrcat(entree1_event_http[3],event_time_http);						// On copie l'heure de l'evenement actuel dans la dernière ligne du tableau (ligne 3 car on débute à 0)
				}
    			else 
				{
      			// Traitement du front descendant
    			}
    			old_state1 = new_state1;
  			}

Je cherche à stocker avec la fonction Eeprom2_save décrite plus haut, la chaine entree1_event_http[3] dès que l'on décale les lignes dans le tableau, immédiatement après :

Code :

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

strcpy(entree1_event_http[i-1],entree1_event_http[i]);

Mais je voudrais que chaque dernière ligne du tableau :

Code :

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

entree1_event_http[3]

soit stockée à l'adresse de départ + 3 caractères :

Exemple, si l'adresse de départ est 0x000000, on aurait à chaque fois que l'on décale une ligne dans le tableau , la dernière ligne stockée à adresse + 3

1er evènement : entree1_event_http[3] stocké en 0x000000
2ème evènement : entree1_event_http[3] stocké en 0x000003
3ème evènemen t : entree1_event_http[3] stocké en 0x000006
4ème evènement : entree1_event_http[3] stocké en 0x000009

etc ...

Pourriez vous m'aider à réaliser cela svp ?
Je vous remercie,

[pfeuh]

Salut,

sorte de ring buffer

En fait, tu cherche à utiliser un tampon circulaire. On déclare un tableau averc un nombre d'éléments max. On déclare un index d'entrée et un index de sortie. Quand on rajoute un objet, on incrémente l'index d'entrée (modulo le nombre d'éléments max). Quand on enlève un objet on incrémente l'index de sortie (modulo le nombre d'éléments max). A n'importe quel moment, on sait s'il y a quelque chose en comparant les deux index: S'ils sont égaux, le tampon est vide.

A+

Pfeuh

[diogene]

... A n'importe quel moment, on sait s'il y a quelque chose en comparant les deux index: S'ils sont égaux, le tampon est vide.

Précise aussi combien valent les pointeurs si le tampon est plein.

[lcoulon]

Mon code de tampon circulaire fonctionne, j'arrive bien à obtenir mes 4 derniers évènements, ils sont stocké dans un tableau à 4 lignes de 2 caractères ( pas de soucis de ce coté là ) :

Je récupère ainsi :

Code :

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

1
2
3
4
5
 
entree1_event_http[0];
entree1_event_http[1];
entree1_event_http[2];
entree1_event_http[3];

En plus de cela, je voudrais stocker chaque nouveau contenu de entree1_event_http[3] dans une mémoire à une adresse qui s'incrémente automatiquement à fois de adresse de départ + 2, et ce avec une capacité de stockage de 100 valeurs.

Quand 100 valeurs auront été stockées , l'adresse de départ du 101ème stockage redeviendra 0x000000 ( adresse initiale )

Je cherche donc quelque chose du style :

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
 
// Paramètre qui indique combien il y a de lignes a décaler ( ici 4 )
for(i=1;<4;i++)											
{
// On copie l'element i vers i-1   ( chaque ligne est décalée d'un rang )
strcpy(entree1_event_http[i-1],entree1_event_http[i]);
 
 
// On copie entree1_event_http[3] vers eeprom_buffer pour le stockage 
strcpy(eeprom_buffer,entree1_event_http[3])
 
for(i = 0; i < 100);
address_start = 0x000000;
 
Eeprom2_save(2, address_start)
address_start = address_start +=0x000003
++i;

Je ne sais pas comment déclarer address_start avec une valeur hexa de départ et ensuite l'incrémenter de 0x000003 pour que chaque eeprom_buffer soit stocké 3 octets plus loin et ce 100 fois de suite.

[pfeuh]

Précise aussi combien valent les pointeurs si le tampon est plein.

le tampon est plein quand l'index d'entrée vaut l'index de sortie après ajout d'un élément. Ce qui n'est pas grave en soi. Ce qui est grave, c'est de rajouter un élément quand le tampon est plein.

[diogene]

le tampon est plein quand l'index d'entrée vaut l'index de sortie après ajout d'un élément.

Ce qui signifie alors que la position des pointeurs est en soi insuffisante pour déterminer l'état du buffer et qu'il faut une variable d'état supplémentaire.

[lcoulon]

Pouvez vous reprendre mon code et me corriger svp, car je ne sais pas faire ce que vous me conseillez .

je ne suis pas à l'aise avec les pointeurs et les incrémentations.

Cordialement,

[souviron34]

Pourriez vous m'aider à réaliser cela svp ?
Je vous remercie,

j'ai un peu de mal avec ton raisonnement...

Tu voudrais un buffer circulaire, mais ta dernière instruction ne "circule" pas, mais s'incrémente...

• Si c'est un buffer circulaire, la dernière instruction est toujours en 3, et il faut "shifter" les autres de -1.
  
• Si tu incrémentes, il suffit de faire adresse=adresse+incrément, adresse étant intiliasé à 0.