Discussion :

[boboss123]

Bonjour,

Je voudrais faire un gestionnaire de message système.
J'ai plusieurs processus asynchrones qui tournent et je voudrais qu'ils écrivent dans un buffer pour indiquer leur état d'avancement (ou s'il y a des erreurs).
Ensuite, je pourrais récupérer ces messages avec un autre processus pour pouvoir les afficher.
Remarque : je travaille sur un petit µControlleur 8-bits donc je dois gagner le maximum de RAM possible et je dois définir une zone memoire fixe pour stoquer ma liste => je ne peux utiliser malloc


Donc voici comment je comptais organiser mes fonctions

fichier .c

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
// permet de gérer les informations systemes
// on crée un buffer qui contient l'état d'avancement des taches en cours puis on les récupère lorsqu'on veut les afficher
// => cela permet de faire une console de debug
 
 
// buffer qui stock les messages
unsigned char MemSystem[MEMSYSTEM_SIZE];
 
 
 
// ajoute une information au gestionnaire de messages systemes
//
// Entrées :
// str : message a ajouter
// type : type du message
// src : source du message
//
// Sortie :
// MessageSystem_AddInfo : revoie FALSE si le message n'a pas pu etre ajouté (buffer MemSystem plein)
BOOL MessageSystem_AddInfo(unsigned char *str, MESSAGESYSTEM_TYPE type, MESSAGESYSTEM_SRC src){
 
}
 
 
// affiche le dernier message systeme
// ptMessage : pointe a l'endroit ou va etre copie le message
// sizemax : taille max du string a recuperer (evite dépassement de buffer)
//
// Sortie :
// aucune
void MessageSystem_GetInfo(StructMessageSystem* ptMessage, unsigned char sizemax){
 
}
 
// affiche le dernier message systeme
//
// Entree :
// filter : indique le filtre utilisé
// ptMessage : pointe a l'endroit ou va etre copié le message
// sizemax : taille max du string a recuperer (évite dépassement de buffer)
//
// Sortie :
// aucune
void MessageSystem_GetInfoFilter(StructMessageSystem* ptMessage, MESSAGESYSTEM_TYPE filter, unsigned char sizemax){
 
}
 
 
 
 
// efface tous les messages systemes (vide le buffer MemSystem)
//
// Sortie :
// aucune
void MessageSystem_ClearAll(void){
 
}

fichier .h

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
#define MEMSYSTEM_SIZE (200); // taille du buffer de stockage des messages
#define MEMSYSTEM_MESSAGE_MAXLEN (48); // taille maximale d'un message
 
 
// identifie le type de message
typedef enum _MESSAGESYSTEM_TYPE {
	MESSAGESYSTEM_INFO = 0,
	MESSAGESYSTEM_WARNING,
	MESSAGESYSTEM_ERROR
} MESSAGESYSTEM_TYPE;
 
// identifie la source du message
// on peut ajouter des elements s'il y a de nouvelles sources a gérer
typedef enum _MESSAGESYSTEM_SRC {
	MESSAGESYSTEM_SRC_HTTP = 0,
	MESSAGESYSTEM_SRC_TELNET,
	MESSAGESYSTEM_SRC_TFTP,
	MESSAGESYSTEM_SRC_ARP
} MESSAGESYSTEM_SRC;
 
// structure d'un message systeme
typedef struct _StructMessageSystem {
	unsigned char *str;
	MESSAGESYSTEM_TYPE type;
	MESSAGESYSTEM_SRC src;
} StructMessageSystem;

1- est-ce que vous pensez que l'organisation est bonne ? dois-je ajouter d'autres focntions ?
2- comment dois-je faire pour ajouter/retirer un element dans mon buffer ? Je ne sais pas trop comment on doit gérer ça vu que :
- chaque message a une taille variable
- je dois pouvoir mettre autant de messages que possible
- lorsque je fais une demande de récupération de message, celui-ci doit etre effacé du buffer mais comment faire pour que cette place devienne libre pour pouvoir recevoir un nouveau message (je n'ai encore jamais programmé une liste de taille dynamique comme celle-ci) ?

merci d'avance

[souviron34]

j'avoue ne pas comprendre...

• Tes différents processus asynchrones , pourquoi écriraient-ils dans un buffer , et pourquoi auraient-ils besoin des fonctions de lecture ?
  
  
• Comment (et pourquoi) voudrais-tu partager le buffer entre tous les processus ??

Le meilleur moyen serait que chaque processus écrive dans un fichier, et que le "gestionnaire" lise en permanence ce fichier (en temps réel, lecture asynchrone).

[boboss123]

[*]Tes différents processus asynchrones , pourquoi écriraient-ils dans un buffer , et pourquoi auraient-ils besoin des fonctions de lecture ?
[*]Comment (et pourquoi) voudrais-tu partager le buffer entre tous les processus ??

lorsqu'un processus veut envoyer un message, il faut bien qu'il le mette a quelque part pour qu'il soit stoqué en attendant qu'il soit traité, non ?

Le meilleur moyen serait que chaque processus écrive dans un fichier, et que le "gestionnaire" lise en permanence ce fichier (en temps réel, lecture asynchrone).

=> il n'y pas de gestionnaire de fichier dans le code de mon programme (je suis avec un petit µC) : je dois tout stoquer en ram (quelques centaines d'octets).
Je pensais partir sur un système de liste chainée. Par contre avec ton histoire de fichier, tu viens de me donner une idée : je vais stoquer mes messages les uns a la suites des autres dans un buffer (lorsque le buffer est plein, je bloquerai l'ajout de nouveau messages) => c'est moins souple comme solution mais c'est plus light

[souviron34]

lorsqu'un processus veut envoyer un message, il faut bien qu'il le mette a quelque part pour qu'il soit stoqué en attendant qu'il soit traité, non ?

Je ne sais pas comment ça marche sur un microC..

Normalement, par exemple quand tu fais fprintf, le message est stocké effectivement dans un buffer, qui est downloadé chaque fois que tu fais "\n" pour stdout, rien (c'est à dire downloadé tout de suite) pour stderr, downloadé si tu fais fflush pour un fichier standard, ou quand le buffer est plein...