message.c

嵌入式环境消息队列软件

#include <stdio.h>
#include <assert.h>

#include "message.h"

#define _MSG_DEBUG

#ifdef _MSG_DEBUG
#define _ASSERT(x) assert(x)
#else
#define _ASSERT(x) 
#endif


#define MSG_QUEUE_MAX_ENTRIES 10

typedef  struct _tagMsg
{                      
	int				id;                           
	int				length;                 
	unsigned char        params[3];  
} TMsg;

typedef  struct _tagMsgQ
{
	struct _tagMsgQ	*next;
	int		 		 id;
	int		 		 in;
	int		 		 out;
	void    	  		*msg[MSG_QUEUE_MAX_ENTRIES];	
}TMsgQ,*TPMsgQ;

static TMsgQ *MsgQList=NULL;

static void perr(IN char *err)
{
	printf("err:%s",err);
	exit(1);	
}

static TMsgQ *MsgQFind(IN int id)
{
	TMsgQ *p=MsgQList;

    //printf("p->id:%d %d\n",p->id,p->next->id);
    //exit(1);
    
	for(;p;p=p->next)
	{
		//printf("p->id:%d\n",p->id);
		if(id==p->id)
			return p;
	}
		
	return NULL;
}


static void MsgPrint(IN unsigned char params[],IN int length)
{
	int i;
	
	printf("  params:");
	for(i=0;i<length;i++)
		printf("%d  ",params[i]);
	printf("\n");
}

void MsgShowSingle(IN unsigned char params[],IN int length)
{
	printf("singe message:\n");
	MsgPrint(params,length);
	printf("-------------------------\n");
}

void MsgShowAll(IN int id)
{
	 int	 i;
     TMsg	*pmsg;
     TMsgQ	*queue;
	
	 queue=MsgQFind(id);
	 
     printf("all messages in queue %d:\n",id);

	 if(queue->in>=queue->out)
	 {
	 	//for(i=g_pMsgQ->out;i<g_pMsgQ->in;i++);
	 	for(i=queue->out;i<queue->in;i++)	 	
	 	{
	 		pmsg=(TMsg*)(queue->msg[i]);
		    MsgPrint(pmsg->params,pmsg->length);
	 	}
	 }
	 else
	 {	
	 	for(i=queue->out;i<MSG_QUEUE_MAX_ENTRIES;i++)
	 	{
	 		pmsg=(TMsg*)queue->msg[i];
	 		MsgPrint(pmsg->params,pmsg->length);
	 	}
	 	for(i=0;i<queue->in;i++)
	 	{
	 		pmsg=(TMsg*)queue->msg[i];
	 		MsgPrint(pmsg->params,pmsg->length);
	 	}
	 }
	 printf("-------------------------\n");
}

static int MsgQPost(IN void *msg)
{
	TMsg *p,*q,*pmsg;
    TMsgQ *queue;
    
    pmsg=(TMsg *)msg;
 
	queue=MsgQFind(pmsg->id);
	if(NULL==queue)
		perr("invalid queue!\n");
    //printf("sizeof(TMsgQ):%d\n",sizeof(queue));
    p=(TMsg*)queue->msg[queue->in];
	q=(TMsg*)msg;
	
	memcpy(p,q,sizeof(TMsg));

    queue->in=(queue->in+1)%MSG_QUEUE_MAX_ENTRIES;
}

static void *MsgQPend(IN int id)
{
	void* msg;
	TMsgQ *queue;
	
	queue=MsgQFind(id);
	
	msg=queue->msg[queue->out]; 	
    queue->out=(queue->out+1)%MSG_QUEUE_MAX_ENTRIES;
    
    return msg;
}

static  TMsgQ * MsgQAppend(IN TMsgQ *list,IN TMsgQ *tMsgQ)
{ 
	static cnt;
  
	TMsgQ **p=&list;
	
  	cnt++;
	
	while(*p) 
	{ 
		if(cnt==6)
		{
			printf("p:0x%0x\n",p);
			printf("*p:0x%0x\n",*p);
			printf("*p->next:0x%0x\n",(*p)->next);
			printf("&(*p)->next:0x%0x\n",&(*p)->next);
		}
	    	p=&(*p)->next;
    	
		if(cnt==6)
		{
 		   	printf("\n");
  		  	printf("p:0x%0x\n",p);
			printf("*p:0x%0x\n",*p);
			printf("*p->next:0x%0x\n",(*p)->next);
			printf("&(*p)->next:0x%0x\n",&(*p)->next);
			exit(1);
		}

	}
		*p=tMsgQ;
  
   
	return list;	
 
}


static TMsgQ * MsgQAdd(IN TMsgQ *list,IN TMsgQ *tMsgQ)
{ 
	static cnt;
 
	TMsgQ **p=&list;
	
	_ASSERT(tMsgQ);
	
	if(list!=NULL)
		tMsgQ->next=(*p);	
	
	(*p)=tMsgQ;
	
	//printf("*list0:0x%0x\n",(*p)->next);

	//printf("*list1:0x%0x\n",(*p));
	return list;  	 
}



 hMsgQId MsgQCreate(void)
{
	int i;
	static int Qid;
	struct _tagMsgQ *MsgQ;
 
	MsgQ=(struct _tagMsgQ *)malloc(sizeof(struct _tagMsgQ*));	

    _ASSERT(MsgQ);    
    
    for(i=0;i<MSG_QUEUE_MAX_ENTRIES;i++)
    {
      MsgQ->msg[i]=(struct _tagMsg*)malloc(sizeof(struct _tagMsg*));
      _ASSERT(MsgQ->msg[i]);
    }     
    
	MsgQ->id=Qid;
	MsgQ->in=0;
	MsgQ->out=0;
	MsgQ->next=NULL;
	 
	MsgQList=MsgQAppend(MsgQList,MsgQ);
	
	return (++Qid -1);
}


int MsgQSend(IN int id,IN unsigned char params[],IN int length)
{
	TMsg msg;
    	
	msg.id=id;
    msg.length=length;
    
    memcpy(msg.params,params,length*sizeof(unsigned char));

    MsgQPost(&msg);
    
    return 1;//ignore result
}

int MsgQRecv(IN int id,OUT unsigned char *params,OUT int *length)
{
	TMsg *msg;	

    msg=(TMsg *)MsgQPend(id);
    
    if(id!=msg->id)
    {
     	printf("error:message queue id!\n");
     	
     	return 0;	
    } 
    memcpy(params,msg->params,msg->length*sizeof(unsigned char));
    
    *length=msg->length;
    
    return 1;
}