comm.c

ucOS 在单片机上实现

#include "includes.h"
#include <machine.h>

#include "comm.h"



////////////////////////////////////////////////////////////////////////////
//		GLOBAL VARIABLES DEFINE BLOCK
SERIAL_COMM_ST  stComm;


////////////////////////////////////////////////////////////////////////////
//		GLOBAL FUNCTIONS PROTOTYPE DEFINE BLOCK
static uint8_t CommDataRead(uint8_t* buf, uint8_t len);

////////////////////////////////////////////////////////////////////////////
//		UART BASIC FUNCTIONS CODE BLOCK
void SerialCommInit(void)
{
	uint16_t i;
	uint8_t *p;

	p = (uint8_t *)&stComm;
	for (i=(uint8_t)0; i<sizeof(stComm); i++)
	{
		*p++ = (uint8_t)0;
	}
	stComm.ucReceiveIndex = (uint8_t)0xA5;
	P_SPCR.BYTE = (uint8_t)0xE0;			// Setting p42/TXD32 is TXD32
	SCI3.SCR3.BYTE = (uint8_t)0x00;		// Stop SCI3
	// Clear Status Flag
	SCI3.SSR.BIT.OER = (uint8_t)0;
	SCI3.SSR.BIT.FER = (uint8_t)0;
	SCI3.SSR.BIT.PER = (uint8_t)0;
	SCI3.SSR.BIT.TDRE = (uint8_t)0;
	SCI3.SSR.BIT.RDRF = (uint8_t)0;

	// Setting SCI3 mode, 8 bits data, 1 stop bit, no parity, no mltiprocessor, clock
	SCI3.SMR.BYTE = (uint8_t)0x00;
	SCI3.BRR = (uint8_t)0x03;			// Setting band rate, 19200bit/s
	SCI3.SCR3.BYTE = 0;//(uint8_t)0xC0;		// Enable Rx Interrupt,Transmit Interrupt Enable

	SCI3.SCR3.BIT.TE = (uint8_t)1;		// transfer enable
	SCI3.SCR3.BIT.RE = (uint8_t)1;		// recvieve enable

    return ;
}

uint8_t CommDataSend(const uint8_t *p,uint8_t ucSendNum)
{
    uint8_t i;
    uint8_t pop;
		
 	i = (uint8_t)0;
	pop = (uint8_t)0;
 	if ( (ucSendNum<=COMM_SEND_MAX_BUF) && (ucSendNum>0) )
	{
		while (i<ucSendNum)
		{
			set_imask_ccr(1);
			pop = stComm.ucSendPop;
			set_imask_ccr(0);

			if (pop > stComm.ucSendPush)
			{
				i = (uint8_t)(pop - stComm.ucSendPush);
			} else
			{
				i = (uint8_t)((uint16_t)((uint16_t)COMM_SEND_MAX_BUF + (uint16_t)pop) - stComm.ucSendPush);
			}
		}

		for (i=(uint8_t)0; i<ucSendNum; i++)
		{
		 	stComm.sendbuf[stComm.ucSendPush++] = *(p+i);
		 	if (stComm.ucSendPush >= COMM_SEND_MAX_BUF)
	 		{
	 			stComm.ucSendPush = (uint8_t)0;
	 		}
		}

		if (stComm.state.BITS.bSending == 0)
		{
			stComm.state.BITS.bSending = (uint8_t)1;
			SCI3.SCR3.BIT.TIE= (uint8_t)1;     	// Transmit Interrupt Enable
		}
	}

	return ;
}

static uint8_t CommDataRead(uint8_t* buf, uint8_t len)
{
	uint8_t ucLength;
	uint8_t	ucRetLen;

	set_imask_ccr(1);
	ucRetLen = stComm.ucReadPush;
	set_imask_ccr(0);

	if (ucRetLen >= stComm.ucReadPop)
	{
		ucLength = (uint8_t)(ucRetLen - stComm.ucReadPop);
	} else
	{
		ucLength = (uint8_t)((uint16_t)((uint16_t)COMM_RECE_MAX_BUF + (uint16_t)ucRetLen) - stComm.ucReadPop);
	}

	if (ucLength >= len)
	{
		for (ucLength=(uint8_t)0; ucLength<len; ucLength++)
		{
			*(buf+ucLength) = stComm.recebuf[stComm.ucReadPop++];
			if (stComm.ucReadPop >= COMM_RECE_MAX_BUF)
			{
				stComm.ucReadPop = (uint8_t)0;
			}
		}
		ucRetLen = len;
	} else
	{
        ucRetLen = (uint8_t)0;
	}

	return ucRetLen;
}

void INT_SCI(void)
{
	if(SCI3.SSR.BIT.TDRE ==1)
	{
#ifdef UART_OLD
	 	if(stComm.ucSendPoint < stComm.ucSendNum)
		{
	   	 	SCI3.TDR = stComm.sendbuf[stComm.ucSendPoint++];
	 	}
#else
		if (stComm.ucSendPop != stComm.ucSendPush)
		{
	   	 	SCI3.TDR = stComm.sendbuf[stComm.ucSendPop++];
	   	 	if (stComm.ucSendPop >= COMM_SEND_MAX_BUF)
   	 		{
				stComm.ucSendPop = (uint8_t)0;
   	 		}
		}
#endif
	}

	if(SCI3.SSR.BIT.RDRF ==1)
	{
#ifdef UART_OLD
		stComm.recebuf[(uint8_t)(INBUF_MASK & stComm.ulRecHead)] = (uint8_t)SCI3.RDR;
		stComm.ulRecHead++;
        if( stComm.ulRecHead - stComm.ulRecBegin>= COMM_RECE_MAX_BUF )
		{
			stComm.ulRecBegin = stComm.ulRecHead - stComm.ulRecBegin;
		}
#else
		uint8_t tmp;
		tmp = stComm.ucReadPush;
		tmp++;
		if (tmp>=COMM_RECE_MAX_BUF)
		{
			tmp = (uint8_t)0;
		}
		if (tmp != stComm.ucReadPop)
		{
			stComm.recebuf[stComm.ucReadPush] = (uint8_t)SCI3.RDR;
			stComm.ucReadPush = tmp;
		}
#endif
	}

	if(SCI3.SSR.BIT.TEND ==(uint8_t)1)
	{
#ifdef UART_OLD
	 	if(stComm.ucSendPoint >= stComm.ucSendNum)
		{
//			SCI3.SCR3.BIT.TE = 0;				// transfer disable
			SCI3.SCR3.BIT.TIE=(uint8_t)0;     	// Transmit Interrupt disable
		}
#else
		if (stComm.ucSendPop == stComm.ucSendPush)
		{
			stComm.state.BITS.bSending = (uint8_t)0;
			SCI3.SCR3.BIT.TIE=(uint8_t)0;     	// Transmit Interrupt disable
			//SPCR.BIT.SPC32 = (uint8_t)0;
		}
#endif
	}

	SCI3.SSR.BIT.OER = (uint8_t)0;
	SCI3.SSR.BIT.FER = (uint8_t)0;
	SCI3.SSR.BIT.PER = (uint8_t)0;
	
}