Gestionnaire de messages system
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:
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:
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
