osek_com.c.svn-base

我们自己开发的一个OSEK操作系统！不知道可不可以？

#include "I_PDU.h"
#include "Message.h"
#include "MessageBuffer.h"
#include "Queue.h"
//#include <stdlib.h>
//#include <math.h>
//#include <stdio.h>


#define IpduSize 10
#define MAXBUFFER 16
#define MessageL 100
#define MAXID 100
#define MINID 0

MessageIdentifier MESSAGE_ID;                                   /*Message ID */
UWORD MESSAGE_LENGTH;                                           /*Message length*/
Alignment ALIGNMENT;                                            /*data alignment*/
Type TRANSMISSION_TYPE;                                         /*inter COM or exter COM*/
Usage MESSAGE_USAGE;                                            /*using mode*/
int QUEUED;                                                     /*queued message or not*/
TX_Notifacation TRANSMISSION_NOT;                               /*transmission notifacation*/
Transmission TRANSMIT_MODE;                                     /*direct,period,mixed*/
char MESSAGE_DATE[MAXSIZE];                                     /*message date*/

int TCNMCR;                                                     /*TouCAN Module Configuration Register*/
int CANTCR;                                                     /*TouCAN Test Configuration Register*/
int CANICR;                                                     /*TouCAN Interrupt Configuration Register*/
char CANCTRL0,CANCTRL1;                                         /*Control Register*/
char PRESDIV,CANCTRL2;                                          /*Prescaler Divide Register*/
int TIMER;                                                      /*Free Running Timer Register*/
unsigned int RXGMSKHI,RXGMSKHO;                                 /*Receive Global Mask Register(High,Low)*/
unsigned int RX14MSKHI,RX14MSKLO;                               /*Receive Buffer 14 Mask Registers*/
unsigned int RX15MSKHI,RX15MSKLO;                               /*Receive Buffer 15 Mask Registers*/
int ESTAT;                                                      /*Error and Status Register*/
int IMASK;                                                      /*Interrupt Mask Register*/
int IFLAG;                                                      /*Interrupt Flag Register*/
char RXECTR,TXECTR;                                             /*Error Counters(Receive,Transmit)*/
int ServiceID;
ServiceType servicetype;

int IDE;
int lbuf;

I_PDU Ipdu_Down[IpduSize];
int Down_Front=0, Down_Rear=0;


I_PDU Ipdu_Up[IpduSize];
int Up_Front=0, Up_Rear=0;


MessageBuffer buffer[MAXID];

SeqQueue *SendMessageQ;
SeqQueue *ReceiveMessageQ,*ReceiveMessageUQ;
SeqQueue a,b1,b2;
	
int abs_test(int p)
{
	if(p >= 0)
		return p;
	else
		return (-p);
}

int mypow(int x,int y)
{
	if(y < 0)
		return 0;
	if(y == 0)
		return 1;
	if(y == 1)
		return x;
	if(y%2 == 0)
		return mypow(x*x,y/2);
	else
		return mypow(x*x,y/2)*x;
}

int IpduEmpty(int front,int rear)
{
	if (front == rear)
		return 1;
	else 
		return 0;
}

int IpduFull(int front,int rear)
{
	if (front == (rear+1)%IpduSize)
		return 1;
	else 
		return 0;	
}


int InitCOM(MessageIdentifier MID,UWORD Length,Alignment alignment,Type type,Usage usage,int Queued,TX_Notifacation tx_Notifacation,Transmission transmission,char Message_Data[MAXSIZE])
{
	if(MID<MINID||MID>MAXID)
	{
		return 0;
	}
	MESSAGE_ID=MID;                                                  /*Init Message ID */

	if(Length>MessageL||Length<0)
	{
		return 0;
	}
	MESSAGE_LENGTH=Length;                                           /*Init Message length*/

	if(alignment!=left&&alignment!=right)
	{
		return 0;
	}
	ALIGNMENT=alignment;                                              /*Init data alignment*/

	if(type!=inter&&type!=exter)
	{
		return 0;
	}
	TRANSMISSION_TYPE=type;                                           /*Init COM mode*/

	if(usage!=send&&usage!=receive&&usage!=send_receive)
	{
		return 0;
	}
	MESSAGE_USAGE=usage;                                              /*Init using mode*/

	QUEUED=Queued;                                                    /*queued message or not*/
	TRANSMISSION_NOT=tx_Notifacation;                                 /*transmission notifacation*/

	if(transmission!=direct&&transmission!=period&&transmission!=mixed)
	{
		return 0;
	}
	TRANSMIT_MODE=transmission;                                       /*direct,period,mixed*/

	int i;
	for(i=0;i<Length;i++)
	{
		MESSAGE_DATE[i]=Message_Data[i];                                     /*message date*/
	}

}
enum StatusType StartCOM(UBYTE COMApplicationModeType)
{
	SendMessageQ=&a;
	InitQueue(SendMessageQ);
	
	if(COMApplicationModeType==0)       /*internal COM*/
	{
		//printf("This COM is internal COM!\n");
		ReceiveMessageQ=&b1;
		ReceiveMessageUQ=&b2;
		InitQueue(ReceiveMessageQ);                                   //Init Message Object
		InitQueue(ReceiveMessageUQ);
		return E_OK;
	}
	if(COMApplicationModeType==1)       /*external COM*/
	{
		//printf("This COM is external COM!\n");
		
		return E_OK;
		
	}
	return E_COM_ID;
}

enum StatusType StopCOM(int COMShundownModeType)
{
	return E_OK;
}

enum COMServiceIDType GetApplicationMode()
{
	/*printf("The application mode is:\n");*/
	return COMServiceID_Send;
}

enum StatusType InitMessage(MessageIdentifier MessageID,ApplicationDataRef *DataRef)
{
	Message m;
	m.MID=MessageID;
	if(m.MID<=0)
		return E_COM_ID;
	int i;
	for(i=0;i<MESSAGE_LENGTH;i++)
	{
		m.Message_Data[i]=MESSAGE_DATE[i];
	}

	m.Length=MESSAGE_LENGTH;

	m.type=TRANSMISSION_TYPE;
	
	m.Queued=QUEUED;

 //将初始化的消息存入发送消息对列

	if(EnterQueue(SendMessageQ,m)==TRUE)
	{
		/*printf("Send to SendMessageQ success!\n");*/
		return E_OK;
	}

	return E_COM_LIMIT;
	
}

enum StatusType StartPeriodic(int PeriTime)
{
	int i;
	for(i=0;i<PeriTime;i++)
	{
		
	}
	return E_OK;

}

enum StatusType StopPeriodic()
{
	return E_OK;
}

enum StatusType MessageToIpdu(Message message)
{
	if (message.type == inter)  /*See if an external message*/
	{
		/*printf("Error:It's not an external message\n");*/
		return E_COM_LIMIT;
	}	
	if (IpduFull(Down_Front,Down_Rear))
	{
		/*printf("Error:Ipdu_Down buffers are full\n");*/
		return E_COM_LIMIT;
	}
	else
	{
		int p; 
		p=IpduSize-abs_test(Down_Front-Down_Rear);
		int q;
		if(message.Length%8==0)
			q=message.Length/8;
		else
			q=message.Length/8+1;
		if(q>p)
		{
			return E_COM_LIMIT;
		}
		else
		{	
			int i,j;
			i=j=0;
			while (message.Message_Data[i] != '*')
			{
				if(j==7)
					{
						j=0;
						Ipdu_Down[Down_Rear].DataLength = 8;
						Ipdu_Down[Down_Rear].IpduID= message.MID;
						Down_Rear++;
					}
				Ipdu_Down[Down_Rear].IpduData[i%8] = message.Message_Data[i];
				i++;
				j++;
			}
			Ipdu_Down[Down_Rear].DataLength = j;
			Ipdu_Down[Down_Rear].IpduID= message.MID;
			return E_OK;
		}
	}
}

enum StatusType SendZeroMessage(MessageIdentifier MessageID)
{
	Message m,n;
	m.MID=MessageID;
	m.Message_Data[0]='*';
	
	if(TRANSMIT_MODE==direct||TRANSMIT_MODE==period)
		StartPeriodic(10000);
	if(EmptyQueue(SendMessageQ)==TRUE)
		return E_COM_NOMSG;
	GetHead(SendMessageQ,&n);
	if(n.type==inter)
	{
		if(n.Queued)
			EnterQueue(ReceiveMessageQ,n);
		else
			EnterQueue(ReceiveMessageUQ,n);
		DeleteQueue(SendMessageQ,&n);
	}
	else
	{
		MessageToIpdu(n);
		DeleteQueue(SendMessageQ,&n);
	}	
	if(TRANSMIT_MODE==direct||TRANSMIT_MODE==period)
		StopPeriodic();
	return E_OK;
}

enum StatusType SendMessage(MessageIdentifier MessageID,ApplicationDataRef *DataRef)
{
	Message n;
	if(TRANSMIT_MODE==direct||TRANSMIT_MODE==period)
	{
		StartPeriodic(10000);
	}
	
	if(EmptyQueue(SendMessageQ)==TRUE)
		return E_COM_NOMSG;
	GetHead(SendMessageQ,&n);
	if(n.type==inter)
	{
		if(n.Queued)
			EnterQueue(ReceiveMessageQ,n);
		else
			EnterQueue(ReceiveMessageUQ,n);
		DeleteQueue(SendMessageQ,&n);
	}
	else
	{
		MessageToIpdu(n);
		DeleteQueue(SendMessageQ,&n);
	}
	
	if(TRANSMIT_MODE==direct||TRANSMIT_MODE==period)
		StopPeriodic();
	return E_OK;

}


enum StatusType ReceiveMessage(MessageIdentifier MessageID,ApplicationDataRef *DataRef)
{
	Message n;
	if(EmptyQueue(ReceiveMessageQ)==TRUE)
		return E_COM_NOMSG;
	GetHead(ReceiveMessageQ,&n);
	
	if(MessageID==n.MID)
	{
		MESSAGE_ID=n.MID;
		if(MessageID<MINID||MessageID>MAXID)
		return E_COM_ID;

		MESSAGE_LENGTH=n.Length;                                           
		ALIGNMENT=n.alignment;                                         
		TRANSMISSION_TYPE=n.type;                                        
        MESSAGE_USAGE=n.usage;                                            
		QUEUED=n.Queued;                                                     
		TRANSMISSION_NOT=n.tx_Notifacation;                              
		TRANSMIT_MODE=n.transmission;   
		
		int i;
		for(i=0;i<n.Length;i++)
		{
			MESSAGE_DATE[MAXSIZE]=n.Message_Data[i];
		}

		if(QUEUED)
		{
			DeleteQueue(ReceiveMessageQ,&n);
		}
		else
			DeleteQueue(ReceiveMessageUQ,&n);
		return E_OK;
	}
	
	return E_COM_ID;

}



enum StatusType SendDynamicMessage(MessageIdentifier MessageID,ApplicationDataRef *DataRef,int MsgLength)
{
	if(MsgLength>MAXSIZE)
	{
		/*printf("Message length is exceed the MAXSIZE\n");*/
		return E_COM_LENGTH;
	}
	Message n,*p;
	p=&n;
	
	if(TRANSMIT_MODE==direct||TRANSMIT_MODE==period)
	{
		StartPeriodic(10000);
	}

	if(EmptyQueue(SendMessageQ)==TRUE)
		return E_COM_NOMSG;

	GetHead(SendMessageQ,&n);
	if(n.type==inter)
	{
		if(n.Queued)
		{
			EnterQueue(ReceiveMessageQ,n);			
		}
		else
		{
			EnterQueue(ReceiveMessageQ,n);
		}

		DeleteQueue(SendMessageQ,p);
	}
	else
	{
		/*printf("The message is external message!\n");*/
		MessageToIpdu(n);
		DeleteQueue(SendMessageQ,p);
	}	

	if(TRANSMIT_MODE==direct||TRANSMIT_MODE==period)
	{
		StopPeriodic();
	}

	return E_OK;
}

enum StatusType ReceiveDynamicMessage(MessageIdentifier MessageID,ApplicationDataRef *DataRef,int MsgLength)
{
	Message n;
	Message *p=&n;

	if(EmptyQueue(ReceiveMessageUQ))
		return E_COM_NOMSG;

	GetHead(ReceiveMessageUQ,&n);

	if(n.MID>MAXID||n.MID<MINID)
	{
		/*printf("The message ID is not right!\n");*/
		return E_COM_LIMIT;
	}
	int i=0;
	while(n.Message_Data[i]!='*')
	{
		MESSAGE_DATE[i]=n.Message_Data[i];
	}

	if(i>MessageL)
	{
		/*printf("Message length is exceed the MAXSIZE\n");*/
		return E_COM_LENGTH;
	}
	if(n.Queued)
	{
		DeleteQueue(ReceiveMessageQ,p);
	}
	else
		DeleteQueue(ReceiveMessageUQ,p);
	return E_OK;

}

int getH(long data)
{
	if(data<mymypow(2,16))
		return 0;
	else
		return (int)(data/mypow(2,16));
}

int getL(long data)
{
	if(data<mypow(2,16))
		return data;
	else
	{
		data=data<<16;
		return (int)(data/mypow(2,16));
	}
}

void ClearMB(MessageBuffer MB)
{
	MB.CS=0;
	MB.ID_High=0;
	MB.ID_Low=0;
	MB.Reserved=0;
	int i;
	for(i=0;i<MAXDATA;i++)
		MB.Data[i]=0;
}

enum StatusType IpduToMessage(Message message)
{
	int i=0;
	int j=0;
	int ServiceID=Ipdu_Up[Up_Front].IpduID;
	while((IpduEmpty(Up_Front,Up_Rear)))
	{
		while(ServiceID==Ipdu_Up[Up_Front].IpduID&&j<8)
		{
			message.Message_Data[i++]=Ipdu_Up[Up_Front].IpduData[j++];
		}
		if(j==8)
		{
			j=0;
			Up_Front++;
		}