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

[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.

[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,

[pfeuh]

Pouvez vous reprendre mon code et me corriger svp,

Je ne peux pas, désolé, car je ne comprends pas tes explications. Elles partent directement dans le code sans vraiment parler de l'intention. D'ailleurs, il n'est pas impossible que le détournement du topic vers le tampon circulaire soit dû à ça.

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.

C'est vrai. Un boolean fait l'affaire. Et si ce boolean est vrai quand un octet arrive, on a écrasement du plus ancien élément du tampon. C'est cependant une des techniques les plus utilisées en réception série, où on remplit le tampon par interruption et où on le vide par scrutation. Quand l'écrasement est détecté, on réinitialise la COM. D'où l'importance du choix de la taille du tampon, pour que la sequence principale ait le temps de scruter correctement en toutes circonstances. On complète le tout par un système de timeout et de checksum.

[lcoulon]

Je vais essayer d'être le plus clair possible :

Je cherche à détecter si un front montant se présente ( passage de 0 à 1 ) sur un octet appelé : ETAT_DIN1; ( d'ou mon code présenté plus haut )


Quand un front montant se présente, alors je stocke une variable appelée
entree1_event_http , le but est sauvegarder les 4 derniers entree1_event_http, lorsque le 5ème front arrive le 1er entree1_event_http stocké est alors perdu et remplacé par le second.


De plus, j'ai aussi besoin de compter le nombre (n) de fronts montants survenus, lorsque ce nombre atteindra 100, le comptage repartira à partir de 0.

Ce comptage me permettra d'incrémenter une adresse hexa qui débutera à 0x000000

Code :

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

address_start = 0x000000;

Ainsi à chaque comptage de front , j'aurai alors address_start qui sera incrémenté comme cela :

address_start = 0x000000 + ( 2 x n ) ;
...
quand n = 99 :
address_start = 0x000000 + ( 2 x 99 );

quand n= 100, n repasse à 0 :
address_start = 0x000000 + ( 2 x 0 );

[pfeuh]

le but est sauvegarder les 4 derniers entree1_event_http, lorsque le 5ème front arrive le 1er entree1_event_http stocké est alors perdu et remplacé par le second.

C'est donc bien un tampon circulaire, mais sauvé en eeprom. Le plus simple serait de le créer en ram et de sauver à chaque fois le tampon complet (les 4 derniers élément si j'ai bien compris) et son index indiquant la position du plus récent élément.

[lcoulon]

Peux tu me proposer un code faisant cela stp ?

idem pour l'incrémentation de address_start avec le comptage n car je ne sais pas comment faire.

[souviron34]

écrit simplement en suite logique ce que tu as exposé dans le message précédent (ça s'appelle faire de l'agorithmique), ensuite réfléchis à la manière dont tu peux le faire, et propose-nous une solution...

C'est simple comme bonjour une fois que tu as écrit en bon français et successivement ce que tu nous a dit plus haut..

[lcoulon]

J'ai écrit cela, pourriez vous me corriger svp ?

Code :

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

1
2
3
BYTE i;
BYTE n;
new_state1 = ETAT_DIN1;

Comment déclarer address_start pour que cette variable contienne une valeur Hexa ?


...

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
 
 
// Détection d'un changement d'état
 
if (old_state1 != new_state1) 
	{
    	if (new_state1 == 1) 
	{
 
// Traitement du front montant
asctime(&tm_time, event_time_http, 7);	// Met dans event_time_http l'heure au format n°7
 
// Sauvegarde des évènements dans tableau de 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 ... )	
   	}
 
// On rempli la dernière ligne du tableau :    			
strcpy(entree1_event_http[3],event_time_http);					
 
// A chaque fois qu'un évenement se présente,  on incrémente address_start = 0x000000 + ( 2 * n )    si  n = 100 on reviens à l'adresse 0x000000 :
 
for(n=0;n<100;++n)
	{
	address_start = 0x000000 + ( 2*n );
	}
// 100 evenements sont survenus, on replace l'adresse à 0x000000 :
	n=0; 
	address_start = 0x000000;
	}
    	else 
	{
      	// Traitement du front descendant
    	}
    	old_state1 = new_state1;

[pfeuh]

J'ai écrit cela, pourriez vous me corriger svp ?

Il n'y a pas pire sourd que celui qui ne veut pas entendre. Tu continues à t'enfoncer dans le code. Je te rappelle le conseil de Souviron:

écrit simplement en suite logique ce que tu as exposé dans le message précédent (ça s'appelle faire de l'agorithmique), ensuite réfléchis à la manière dont tu peux le faire, et propose-nous une solution...

C'est simple comme bonjour une fois que tu as écrit en bon français et successivement ce que tu nous a dit plus haut..

[diogene]

Comment déclarer address_start pour que cette variable contienne une valeur Hexa ?

Par exemple, address_start étant utilisée pour adresser des bytes :

Code :

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

1
2
3
4
5
char * address_start ;
for(n=0;n<100;++n)
{
    address_start = (char *) 0x000000 + ( 2*n );
}

Maintenant, c'est à toi de savoir si les adresses ainsi obtenues sont légales !

[lcoulon]

Pour répondre à pfeuh et diogene, je récapitule ici mes besoins et propose le code suivant :

- Détection d'un front montant

si oui :

- Déplace chque ligne du tableau à ligne -1 afin d'avoir le dernier evenement sotcké en dernière ligne du tableau.

- Compte le nb d'évements survenus grâce à n.

- Fait le calcul suivant afin d'utiliser address_start comme pointeur d'adresse pour écrire 100 évenements dans une mémoire auxilaire : address_start = 0x000000 + ( 2*n )

[ n doit être converti en hexa pour que le résultat final soit correct ]

- Lorsque 100 évenements seront survenus, n sera ré-initialisé et address_start reprendra la valeur de 0x000000

si non :
- Pas de front montant détécté -> ne fait rien et sort de la boucle.

Ci joint le code modifié avec la recommandation de diogene :

Code :

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

1
2
3
4
BYTE i;
BYTE n;
new_state1 = ETAT_DIN1;
char * address_start ;

...

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
// Détection d'un changement d'état
 
if (old_state1 != new_state1) 
	{
    	if (new_state1 == 1) 
	{
 
// Traitement du front montant
asctime(&tm_time, event_time_http, 7);	// Met dans event_time_http l'heure au format n°7
 
// Sauvegarde des évènements dans tableau de 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 ... )	
   	}
 
// On rempli la dernière ligne du tableau :    			
strcpy(entree1_event_http[3],event_time_http);					
 
// A chaque fois qu'un évenement se présente,  on incrémente address_start = 0x000000 + ( 2 * n )    si  n = 100 on reviens à l'adresse 0x000000 :
 
for(n=0;n<100;++n)
{
    address_start = (char *) 0x000000 + ( 2*n );
}
// 100 evenements sont survenus, on replace l'adresse à 0x000000 :
	n=0; 
	address_start = (char *) 0x000000;
 
}
    	else 
	{
      	// Traitement du front descendant
    	}
    	old_state1 = new_state1;

Maintenant, c'est à toi de savoir si les adresses ainsi obtenues sont légales !

Tu as raison, en effet, ce n'est pas certain que ça fonctionne, car n est un chiffre décimal. ( comptage )

Je pense qu'il faut convertir n de déciaml en hexa pour que la mulitplication donne un résultat en hexa correct, comment puis je faire cela ?

[diogene]

- Fait le calcul suivant afin d'utiliser address_start comme pointeur d'adresse pour écrire 100 évenements dans une mémoire auxilaire : address_start = 0x000000 + ( 2*n )

[ n doit être converti en hexa pour que le résultat final soit correct ]
....
Tu as raison, en effet, ce n'est pas certain que ça fonctionne, car n est un chiffre décimal. ( comptage )

Je pense qu'il faut convertir n de déciaml en hexa pour que la mulitplication donne un résultat en hexa correct, comment puis je faire cela ?

Ca n'a aucune importance que n soit en décimal ou en hexadécimal. Ce ne sont que des représentations physiques (visuelles) des valeurs : en machine, elles sont représentées toutes deux par le code binaire utilisé par le type de la donnée.

La question que je soulevais (par prudence) était simplement :
L'adresse 0 (ou 0x0, c'est la même chose) est certainement légale dans le cadre du langage C ( cf NULL). Mais 0 et les suivantes 2,4,6... le sont-elles dans le cadre de ton programme ? C'est toi qui le sait.