uart.c

C语言编写的监控中心终端程序。基于GPRS上传收发数据功能

#include "stdlib.h"
#include "config.h"
#include "regmap.h"
#include "bufloc.h"
#include "global.h"
#include "memmap.h"
#include "sio.h"
#include "gpio.h"
#include "func.h"
#include "util.h"
#include "uart.h"

void MicroDelay(UINT32 Count)
{
    UINT32		i;

    for (i = 0; i < Count; i++)
	asm volatile ("nop");
}

void InitUartVar()
{
    UartBandRate	= UART_9600;
#ifdef SUPPORT_GPS_FUNCTION
    UartBandDone	= FALSE;
    UartBandStep	= 5;
#endif
}

void UartInitBand()
{
    UartSendWP = UartSendRP = 0;
    UartRecvWP = UartRecvRP = 0;

    UART_LSR = UART_SOFTRESET;		// soft reset
//  Disable interrupt
    UART_ISC = 0;			// 1 << 5;

    switch (UartBandRate) {
    case 4800:
	UART_DIV_L = (67500000 / 16 / UART_4800) & 0xFF;
	UART_DIV_H = (67500000 / 16 / UART_4800) >> 8;
	break;
    case 9600:
	UART_DIV_L = (67500000 / 16 / UART_9600) & 0xFF;
	UART_DIV_H = (67500000 / 16 / UART_9600) >> 8;
	break;
    }

    UART_LCR = UART_8bits | UART_ONESTOPBIT | UART_DISABLEPARITY | UART_VOTESEL0;
//  UART_MCR = UART_AUTO_RTS | UART_AUTO_CTS;
//  Enable interrupt
    UART_ISC = 1 << 5;

    UartRecvStep	= UART_RECV_PROC_IDLE;
    UartDataSize	= 0;
    UartKeepSize	= 0;
    UartUserSize	= 0;
    UartBandSize	= 0;
    UartTestSize	= 0;
}

void UartSend(UINT8 *a, UINT8 n)
{
    while (n > 0) {
	UartSendBuffer[UartSendWP++] = *a++;
	UartSendWP &= UART_BUFFER_MASK;
	n--;
    }
}

BYTE UartRecv(UINT8 *a, UINT8 n)
{
    BYTE		ReceiveCount = 0;

    while (n > 0 && UartRecvWP != UartRecvRP) {
	*a++ = UartRecvBuffer[UartRecvWP++];
	UartRecvWP &= UART_BUFFER_MASK;
	ReceiveCount++;
	n--;
    }
    return ReceiveCount;
}

void PollingUartSend()
{
    if (UartSendRP != UartSendWP) {
	if (!IsUARTCmdTxFull())	{
	    regs0->uart0_data = UartSendBuffer[UartSendRP++];
	    UartSendRP &= UART_BUFFER_MASK;
	}
    }
}

void WaitingUartSend()
{
    while (UartSendRP != UartSendWP) {
	PollingUartSend();
    }
}

#if 0
void PollingUartRecv()
{
//  if (UartRecvRP - UartRecvWP)
    {
	if (!IsUARTCmdRxEmpty()) {
	    UartRecvBuffer[UartRecvRP++] = regs0->uart0_data;
	    UartRecvRP &= UART_BUFFER_MASK;
	}
    }
}
#endif

void intr_uart(void)
{
//  if (UartRecvRP - UartRecvWP)
    {
	if (!IsUARTCmdRxEmpty()) {
	    UartRecvBuffer[UartRecvRP++] = regs0->uart0_data;
	    UartRecvRP &= UART_BUFFER_MASK;
	}
    }
}

#ifdef SUPPORT_GPS_FUNCTION
BYTE UartRecvData()
{
    BYTE		Size;
    UINT16		i, j;
    BYTE		k;

    if (UartKeepSize) {
	Size = UartKeepSize;
	UartKeepSize = 0;
    }
    else
    if ((Size = UartRecv(UartData, UART_RECV_SIZE)) == 0)
	return 0;

    if (UartBandDone == FALSE) {
	UartData[Size] = 0;
	ShowDebugStr(UartData, 4);

	memcpy(GPSBandBuffer + UartBandSize, UartData, Size);
	UartBandSize += Size;
	if (UartBandSize >= 60) {
	    for (i = 0; i < UartBandSize; i++) {
		if (!(IsPrint(GPSBandBuffer[i]) ||
		      GPSBandBuffer[i] == 0x0D  || GPSBandBuffer[i] == 0x0A))
		    continue;
		for (k = 0, j = i + 1; j < UartBandSize && k < 20; j++, k++) {
		    if (!IsPrint(GPSBandBuffer[j]))	break;
		}
		if (k >= 20) {
		    ShowDebugDec(UartBandRate, 3);
		    UartBandDone = TRUE;
		    break;
		}
	    }
	    if (UartBandDone == FALSE) {
		UartBandSize -= 60;
		memcpy(GPSBandBuffer, GPSBandBuffer + 60, UartBandSize);
		if (UartBandStep) {
		    UartBandStep--;
		}
		else {
		    UartBandStep = 5;
		    switch (UartBandRate) {
		    case UART_4800: UartBandRate = UART_9600;	break;
		    default:	    UartBandRate = UART_4800;	break;
		    }
		    UartInitBand();
		    ShowDebugDec(UartBandRate, 11);

#ifdef TEST_GPS_MODULE
		    psprintf(LineBuffer, "GPS Band : %-4d", UartBandRate);
		    MenuScreenIndex = 0;
		    MenuPrintString(0, 7, LineBuffer);
#endif
		}
	    }
	}
    }

#ifdef TEST_GPS_MODULE
    memcpy(GPSTestBuffer + UartTestSize, UartData, Size);
    UartTestSize += Size;
    if (UartTestSize >= 39) {
	strcpylen(LineBuffer, GPSTestBuffer, 39);
	for (i = strlen(LineBuffer); i < 39; i++) LineBuffer[i] = ' '; LineBuffer[i] = 0;
	MenuScreenIndex = 0;
	MenuPrintString(0, 8, LineBuffer);
	UartTestSize -= 39;
	memcpy(GPSTestBuffer, GPSTestBuffer + 39, UartTestSize);
    }
#endif

#ifdef SUPPORT_GPS_TR2000
    if (UartRecvStep == UART_RECV_PROC_IDLE) {
	for (i = 0; i < Size; i++) {
	    if (UartData[i] == 'B')
		break;
	}
	if (i >= Size)
	    return 0;

	for (j = i + 1; j < Size; j++) {
	    UartData[j - i - 1] = UartData[j];
	}
	Size -= i + 1;

	GPSUserBuffer[0] = 'B';
	UartDataSize = 1;
	UartRecvStep = UART_RECV_PROC_DATA;
    }

    if (UartRecvStep == UART_RECV_PROC_DATA) {
	for (i = 0; i < Size; i++) {
	    if (UartDataSize >= 512 - 1) {
		UartDataSize = 0;
		UartRecvStep = UART_RECV_PROC_IDLE;
		return 0;
	    }

	    GPSUserBuffer[UartDataSize++] = UartData[i];
	    if (GPSUserBuffer[1] != 'T')
		return 0;

	    if (UartData[i] == '\x0A') {
		UartKeepSize = Size - i - 1;
		for (j = 0; j <	UartKeepSize; j++) {
		    UartData[j] = UartData[i + j];
		}
		UartRecvStep = UART_RECV_PROC_IDLE;
		return 1;
	    }
	}
    }
#elif defined(SUPPORT_GPS_MOSUSS)
    memcpy(GPSUserBuffer + UartUserSize, UartData, Size);
    UartUserSize += Size;
    if (UartRecvStep == UART_RECV_PROC_IDLE) {
	if (UartUserSize < 2 + 1)
	    return 0;
	for (i = 0; i < UartUserSize - 2; i++) {
	    if (GPSUserBuffer[i] == 0x1A && GPSUserBuffer[i + 1] == 0xE5)
		break;
	}
	if (i >= UartUserSize - 2) {
	    GPSUserBuffer[0] = GPSUserBuffer[UartUserSize - 2];
	    GPSUserBuffer[1] = GPSUserBuffer[UartUserSize - 1];
	    UartUserSize = 2;
	    return 0;
	}

	UartBodySize  = GPSUserBuffer[i + 2];
	for (j = i + 3; j < UartUserSize; j++) {
	    GPSUserBuffer[j - i - 3] = GPSUserBuffer[j];
	}
	UartUserSize -= i + 3;
	UartRecvStep  = UART_RECV_PROC_DATA;
    }

    if (UartRecvStep == UART_RECV_PROC_DATA) {
	if (UartUserSize > UartBodySize) {
	    UartRecvStep = UART_RECV_PROC_IDLE;
	    return 1;
	}
    }
#else
    if (UartRecvStep == UART_RECV_PROC_IDLE) {
	for (i = 0; i < Size; i++) {
	    if (UartData[i] == '$')
		break;
	}
	if (i >= Size)
	    return 0;

	for (j = i + 1; j < Size; j++) {
	    UartData[j - i - 1] = UartData[j];
	}
	Size -= i + 1;

	GPSDataBuffer[0] = '$';
	UartDataSize = 1;
	UartRecvStep = UART_RECV_PROC_DATA;
    }

    if (UartRecvStep == UART_RECV_PROC_DATA) {
	for (i = 0; i < Size; i++) {
	    if (UartDataSize >= 100 - 1) {
		UartDataSize = 0;
		UartRecvStep = UART_RECV_PROC_IDLE;
		return 0;
	    }

	    if (!(UartData[i] == '$' || UartData[i] == '\x0D' || UartData[i] == '\x0A'))
		GPSDataBuffer[UartDataSize++] = UartData[i];

	    if ((UartDataSize > 3 && GPSDataBuffer[UartDataSize - 3] == '*') ||
		UartData[i] == '$' || UartData[i] == '\x0D' || UartData[i] == '\x0A') {
		if (UartData[i] != '$')	i++;

		UartKeepSize = Size - i;
		for (j = 0; j <	UartKeepSize; j++) {
		    UartData[j] = UartData[i + j];
		}
		UartRecvStep = UART_RECV_PROC_IDLE;
		return 1;
	    }
	}
    }
#endif

    return 0;
}

BYTE UartRecvGPS()
{
    BYTE		i;

    if (UartRecvData()) {
#ifdef SUPPORT_GPS_TR2000
	GPSUserBuffer[UartDataSize] = '\0';
	if (UartDataSize > 4) {
	    if (memcmp(GPSUserBuffer, "BTGG", 4) == 0) {
		strcpy(GPSDataBuffer, GPSUserBuffer + 4);
		UartDataSize -= 4;
	    }
	    else {
		HostReceive();
		return GPS_RECV_IDLE;
	    }
	}
#elif defined(SUPPORT_GPS_MOSUSS)
	HostReadUartData();
#else
	GPSDataBuffer[UartDataSize] = '\0';
#endif

#ifdef SUPPORT_TOUCH_PILOT_FUNCTION
	if (UartDataSize > 5) {
#elif defined(TEST_GPS_MODULE)
	if (UartDataSize > 5) {
#else
	if (UartDataSize > 20) {
#endif
	    if (strncmp(GPSDataBuffer + 1, "GPRMC", 5) == 0) {
#ifdef TEST_GPS_MODULE
		strcpylen(LineBuffer, GPSDataBuffer, 39);
		MenuPrintMessage(1);
		strcpylen(LineBuffer, GPSDataBuffer + 39, 39);
		MenuPrintMessage(2);
#endif

		for (i = 6; i < 20; i++) {
		    if (GPSDataBuffer[i] == 'V') return GPS_RECV_CALCULATE;
		    if (GPSDataBuffer[i] == 'A') return GPS_RECV_DATA_GPRMC;
		}
	    }
	    else if (strncmp(GPSDataBuffer + 1, "GPGGA", 5) == 0) {
#ifdef TEST_GPS_MODULE
		strcpylen(LineBuffer, GPSDataBuffer, 39);
		MenuPrintMessage(3);
		strcpylen(LineBuffer, GPSDataBuffer + 39, 39);
		MenuPrintMessage(4);
#endif
		return GPS_RECV_DATA_GPGGA;
	    }
#ifdef SUPPORT_TOUCH_PILOT_FUNCTION
	    else if (strncmp(GPSDataBuffer + 1, "GTMLH", 5) == 0) {
#ifdef TEST_GPS_MODULE
		strcpylen(LineBuffer, GPSDataBuffer, 39);
		MenuPrintMessage(3);
		strcpylen(LineBuffer, GPSDataBuffer + 39, 39);
		MenuPrintMessage(4);
#endif
		return GPS_RECV_DATA_GTMLH;
	    }
#endif
	}
    }

    return GPS_RECV_IDLE;
}
#endif

#ifdef SUPPORT_TEST_FUNCTION
void TestUartSend()
{
#ifdef SUPPORT_UART_VOICE
    BYTE		UartData[] = "广州市丰凌电器有限公司";

    VoiceSend(UartData);
#endif
//  UartSend(UartData, 16);
//  psprintf(LineBuffer, "UART Send : %s", UartData);
//  MenuPrintMessage(2);
}

void TestUartRecv()
{
    BYTE		Size;
    BYTE		UartData[9];

    Size = UartRecv(UartData, 8);
    UartData[Size] = 0;

//  psprintf(LineBuffer, "UART Received : %s", UartData);
//  MenuPrintMessage(2);
}

void TestUartRecvData()
{
    BYTE		i;

    if (UartRecvData()) {
	GPSDataBuffer[UartDataSize] = 0;	// For display

	for (i = 0; i < 39; i++)
	    LineBuffer[i] = GPSDataBuffer[i];
	LineBuffer[39] = 0;
	MenuPrintMessage(3);
	if (UartDataSize > 39) {
	    for (i = 0; i < 39; i++)
		LineBuffer[i] = GPSDataBuffer[i + 39];
	    MenuPrintMessage(4);
	}
    }
}
#endif