dsa.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 "ircmd.h"

#ifdef SUPPORT_DSA_DEVICE

/************************************************************************
 *	DSA Interface Define						*
 ************************************************************************/
#define	DSA_STB			52
#define	DSA_DAT			51
#define	DSA_ACK			50

#define	DSA_STB_HIGH		(GPIO_E_SET(DSA_STB, 0))
#define	DSA_DAT_HIGH		(GPIO_E_SET(DSA_DAT, 0))
#define	DSA_ACK_HIGH		(GPIO_E_SET(DSA_ACK, 0))
#define	DSA_STB_LOW		(GPIO_O_SET(DSA_STB, 0)); (GPIO_E_SET(DSA_STB, 1))
#define	DSA_DAT_LOW		(GPIO_O_SET(DSA_DAT, 0)); (GPIO_E_SET(DSA_DAT, 1))
#define	DSA_ACK_LOW		(GPIO_O_SET(DSA_ACK, 0)); (GPIO_E_SET(DSA_ACK, 1))
#define	DSA_STB_READ		(GPIO_I_GET(DSA_STB))
#define	DSA_DAT_READ		(GPIO_I_GET(DSA_DAT))
#define	DSA_ACK_READ		(GPIO_I_GET(DSA_ACK))

/************************************************************************
 *	DSA Bus Variabler						*
 ************************************************************************/
#define	FIFO_SEND_MASK		(DSA_FIFO_SIZE - 1)
#define	FIFO_RECV_MASK		(DSA_FIFO_SIZE - 1)

#define	FIFO_SEND_FI(d)		*(DSASendFIFO + (DSASendFI++)) = (d); \
				DSASendFI &= FIFO_SEND_MASK
#define	FIFO_SEND_FO(d)		(d) = *(DSASendFIFO + (DSASendFO++)); \
				DSASendFO &= FIFO_SEND_MASK
#define	FIFO_SEND_FO_BACK(d)	DSASendFO--;			      \
				DSASendFO &= FIFO_SEND_MASK;	      \
				*(DSASendFIFO + (DSASendFO)) = (d)
#define	FIFO_RECV_FI(d)		*(DSARecvFIFO + (DSARecvFI++)) = (d); \
				DSARecvFI &= FIFO_RECV_MASK
#define	FIFO_RECV_FO(d)		(d) = *(DSARecvFIFO + (DSARecvFO++)); \
				DSARecvFO &= FIFO_RECV_MASK
#define	FIFO_SEND_EMPTY		(DSASendFI == DSASendFO)
#define	FIFO_RECV_EMPTY		(DSARecvFI == DSARecvFO)
#define	FIFO_SEND_FULL		(((DSASendFI + 1) & FIFO_SEND_MASK) == DSASendFO)
#define	FIFO_RECV_FULL		(((DSARecvFI + 1) & FIFO_RECV_MASK) == DSARecvFO)

#ifdef SUPPORT_GSM_GUARD
#define	FIFO_DATA_FI(d)		*(GSMDataFIFO + (GSMDataFI++)) = (d)
#define	FIFO_DATA_FO(d)		(d) = *(GSMDataFIFO + (GSMDataFO++))
#define	FIFO_DATA_EMPTY		(GSMDataFI == GSMDataFO)
#define	FIFO_DATA_FULL		((GSMDataFI + 1) == GSMDataFO)
#endif

#ifdef SUPPORT_VCD_HOST
#define	FIFO_HOST_SIZE		(64)
#define	FIFO_HOST_MASK		(FIFO_HOST_SIZE - 1)

#define	FIFO_HOST_FI(d)		*(VCDHostFIFO + (VCDHostFI++)) = (d); \
				VCDHostFI &= FIFO_HOST_MASK
#define	FIFO_HOST_FO(d)		(d) = *(VCDHostFIFO + (VCDHostFO++)); \
				VCDHostFO &= FIFO_HOST_MASK
#define	FIFO_HOST_EMPTY		(VCDHostFI == VCDHostFO)
#define	FIFO_HOST_FULL		(((VCDHostFI + 1) & FIFO_HOST_MASK) == VCDHostFO)
#endif

#ifdef SUPPORT_GPRS_CENTER
#define	GPRS_SEND_INTERVAL	(5 * 1000 / 10)
#endif

/************************************************************************
 *	DSA Subroutine							*
 ************************************************************************/
void FinishDSA()
{
    DSA_STB_HIGH;
    DSA_DAT_HIGH;
    DSA_ACK_HIGH;

    DSAStep		= 0;
    DSABitCount		= 0;
    DSATryCount		= 0;
    DSASendFlag		= FALSE;
}

void DSAInitGPIO()
{
    GPIO_M_SET(DSA_STB, 1);
    GPIO_M_SET(DSA_DAT, 1);
    GPIO_M_SET(DSA_ACK, 1);
    GPIO_O_SET(DSA_STB, 0);
    GPIO_O_SET(DSA_DAT, 0);
    GPIO_O_SET(DSA_ACK, 0);

    DSASendFI		= 0;
    DSASendFO		= 0;
    DSARecvFI		= 0;
    DSARecvFO		= 0;
#if defined(SUPPORT_GSM_GUARD) || defined(SUPPORT_GPRS_CENTER)
    GSMDataFI		= 0;
    GSMDataFO		= 0;
#endif
#ifdef SUPPORT_VCD_HOST
    VCDHostFI		= 0;
    VCDHostFO		= 0;

    VCDCommStep		= 0;
    VCDRecvFlag		= 0;
#endif

    FinishDSA();

#if SUPPORT_DSA_VERSION > 19
    DSAVerHard		= 0;
    DSAVerSoft		= 0;
    DSAVerMisc		= 0;
#endif

#ifdef SUPPORT_GPRS_CENTER
    DSASendGPRSFlag	= TRUE;
    DSASendGPRSTime	= GPRS_SEND_INTERVAL;
#endif

#ifdef SUPPORT_DBUS_FUNCTION
    DSARecvFlag		= FALSE;
#endif

#ifdef SUPPORT_GSM_GUARD
    GSMCommType 	= 0;
    GSMCommSize 	= 0;
    GSMCommAddr 	= 0;
#endif
}

void DSASendData(BYTE Comm, BYTE Data)
{
    DSASendDataBackup = (Comm << 8) | Data;
    FIFO_SEND_FI(DSASendDataBackup);
    DSASendDoneFlag = FALSE;
}

void DSAWaitSendDone()
{
    while (!DSASendDoneFlag) {
	polling();
    }
}

#if defined(SUPPORT_GSM_GUARD) || defined(SUPPORT_GPRS_CENTER)
void DSASendGSM(UINT16 Data)
{
    FIFO_DATA_FI(Data);
}
#endif

#ifdef SUPPORT_GSM_GUARD
void DSASendGSMInfo(BYTE *Info, BYTE Type)
{
    BYTE		Len;
    BYTE		Max;
    BYTE		i;

    switch (Type) {
    case COMM_GSM_NAME:		Max =  6;	break;
    case COMM_GSM_CODE:		Max =  6;	break;
    case COMM_GSM_CARTEL:
    case COMM_GSM_CENTER:
    case COMM_GSM_MASTER:
    case COMM_GSM_HOSTER:
    case COMM_GSM_GUARD1:
    case COMM_GSM_GUARD2:
    case COMM_GSM_GUARD3:	Max = 11;	break;
    case COMM_GSM_GUARD0:	Max = 12;	break;
    case COMM_GPS_LANG:		Max =  9;	break;
    case COMM_GPS_LAT:		Max =  9;	break;
    case COMM_GPS_SPEED:	Max =  3;	break;
    case COMM_GPS_ANGLE:	Max =  3;	break;
    case COMM_GPS_TIME:		Max =  8;	break;
    case COMM_GPS_POSI:		Max = 64;	break;
    default:
	return;
    }

    if (Type == COMM_GPS_POSI)	{ StrToPDUText(UnicodeBuffer, Info); }
    else			{ strcpy(UnicodeBuffer, Info);	     }
    UnicodeBuffer[Max] = 0;
    Len = strlen(UnicodeBuffer);

    DSASendGSM((Type << 8) | Len);
    for (i = 0; i < Len; i++) {
	DSASendGSM((i << 8) | UnicodeBuffer[i]);
    }

#ifdef MONITOR_HARDWARE_TEST
    if (Type == COMM_GPS_POSI) {
	ShowDebugStr(Info, 0);
	ShowDebugStr(UnicodeBuffer, 1);
    }
    if (Type == COMM_GPS_SPEED) {
	ShowDebugStr(UnicodeBuffer, 2);
    }
#endif
}
#endif

#if defined(SUPPORT_GSM_GUARD) || defined(SUPPORT_GPRS_CENTER)
void DSASendGSMPosi()
{
#ifdef SUPPORT_GSM_GUARD
    strcpy(LineBuffer, GoalInfoPosi);
    DSASendGSMInfo(LineBuffer, COMM_GPS_POSI);

    psprintf(LineBuffer, "%03d.%02d.%02d",
			 (GoalInfoLang / 100 / 3600),
			 (GoalInfoLang / 100 / 60 % 60),
			 (GoalInfoLang / 100 % 60));
    DSASendGSMInfo(LineBuffer, COMM_GPS_LANG);

    psprintf(LineBuffer, "%02d.%02d.%02d",
			 (GoalInfoLat / 100 / 3600),
			 (GoalInfoLat / 100 / 60 % 60),
			 (GoalInfoLat / 100 % 60));
    DSASendGSMInfo(LineBuffer, COMM_GPS_LAT);

    psprintf(LineBuffer, "%d", GoalInfoSpeed);
    DSASendGSMInfo(LineBuffer, COMM_GPS_SPEED);

    psprintf(LineBuffer, "%d", GoalInfoAngle);
    DSASendGSMInfo(LineBuffer, COMM_GPS_ANGLE);

    psprintf(LineBuffer, "%02d:%02d:%02d",
			 (GoalInfoTime / 3600),
			 (GoalInfoTime / 60 % 60),
			 (GoalInfoTime % 60));
    DSASendGSMInfo(LineBuffer, COMM_GPS_TIME);
#endif

#ifdef SUPPORT_GPRS_CENTER
    BYTE		i;
    BYTE		XorSum;

    LineBuffer[0x00] = (GPSMessage.Point.N >> 24) & 0xFF;
    LineBuffer[0x01] = (GPSMessage.Point.N >> 16) & 0xFF;
    LineBuffer[0x02] = (GPSMessage.Point.N >>  8) & 0xFF;
    LineBuffer[0x03] = (GPSMessage.Point.N      ) & 0xFF;
    LineBuffer[0x04] = (GPSMessage.Point.E >> 24) & 0xFF;
    LineBuffer[0x05] = (GPSMessage.Point.E >> 16) & 0xFF;
    LineBuffer[0x06] = (GPSMessage.Point.E >>  8) & 0xFF;
    LineBuffer[0x07] = (GPSMessage.Point.E      ) & 0xFF;
    LineBuffer[0x08] = (GPSMessage.Speed   >>  8) & 0xFF;
    LineBuffer[0x09] = (GPSMessage.Speed	) & 0xFF;
    LineBuffer[0x0A] = (GPSMessage.Angle   >>  8) & 0xFF;
    LineBuffer[0x0B] = (GPSMessage.Angle	) & 0xFF;
    LineBuffer[0x0C] = (GPSMessage.Time.hh      );
    LineBuffer[0x0D] = (GPSMessage.Time.mm      );
    LineBuffer[0x0E] = (GPSMessage.Time.ss      );
    strcpy(LineBuffer + 0x0F, GPSMessage.Name);

    XorSum = 0;
    for (i = 0; i < GPS_MESSAGE_SIZE; i++) {
	DSASendGSM((i << 8) | LineBuffer[i]);
	XorSum ^= LineBuffer[i];
    }
    DSASendGSM((i << 8) | XorSum);
#endif
}
#endif

#ifdef SUPPORT_GSM_GUARD
void DSASendGSMData(BYTE *Data, BYTE Type)
{
    switch (Type) {
    case COMM_GSM_NAME:
	strcpylen(GSMCarNameID,	    Data, GSM_PASSWORD_LEN);
	break;
    case COMM_GSM_CODE:
	strcpylen(GSMGuestCode,	    Data, GSM_PASSWORD_LEN);
	break;
    case COMM_GSM_CARTEL:
	strcpylen(GSMMobileBuff[0], Data, MOBILE_DIGIT_LEN);
	break;
    case COMM_GSM_CENTER:
	strcpylen(GSMMobileBuff[1], Data, MOBILE_DIGIT_LEN);
	break;
    case COMM_GSM_MASTER:
	strcpylen(GSMMobileBuff[2], Data, MOBILE_DIGIT_LEN);
	break;
    case COMM_GSM_HOSTER:
	strcpylen(GSMMobileBuff[3], Data, MOBILE_DIGIT_LEN);
	break;
    case COMM_GSM_GUARD0:
	strcpylen(GSMMobileBuff[4], Data, MOBILE_PHONE_MAX);
	break;
    case COMM_GSM_GUARD1:
	strcpylen(GSMMobileBuff[5], Data, MOBILE_DIGIT_LEN);
	break;
    case COMM_GSM_GUARD2:
	strcpylen(GSMMobileBuff[6], Data, MOBILE_DIGIT_LEN);
	break;
    case COMM_GSM_GUARD3:
	strcpylen(GSMMobileBuff[7], Data, MOBILE_DIGIT_LEN);
	break;
    default:
	return;
    }

    DSASendGSMInfo(Data, Type);

#ifdef MONITOR_HARDWARE_TEST
    ShowDebugStr(Data, 4);
    ShowDebugHex(Type, 5);
#endif
}

void DSASaveGSMData()
{
    switch (GSMCommType) {
    case COMM_GSM_NAME:
	strcpylen(GSMCarNameID,	    GSMCommBuff, GSM_PASSWORD_LEN);
	TestGuardState |= (1 << 0);
	break;
    case COMM_GSM_CODE:
	strcpylen(GSMGuestCode,	    GSMCommBuff, GSM_PASSWORD_LEN);
	TestGuardState |= (1 << 1);
	break;
    case COMM_GSM_CARTEL:
	strcpylen(GSMMobileBuff[0], GSMCommBuff, MOBILE_DIGIT_LEN);
	TestGuardState |= (1 << 2);
	break;
    case COMM_GSM_CENTER:
	strcpylen(GSMMobileBuff[1], GSMCommBuff, MOBILE_DIGIT_LEN);
	TestGuardState |= (1 << 3);
	break;
    case COMM_GSM_MASTER:
	strcpylen(GSMMobileBuff[2], GSMCommBuff, MOBILE_DIGIT_LEN);
	TestGuardState |= (1 << 4);
	break;
    case COMM_GSM_HOSTER:
	strcpylen(GSMMobileBuff[3], GSMCommBuff, MOBILE_DIGIT_LEN);
	TestGuardState |= (1 << 5);
	break;
    case COMM_GSM_GUARD0:
	strcpylen(GSMMobileBuff[4], GSMCommBuff, MOBILE_PHONE_MAX);
	TestGuardState |= (1 << 6);
	break;
    case COMM_GSM_GUARD1:
	strcpylen(GSMMobileBuff[5], GSMCommBuff, MOBILE_DIGIT_LEN);
	TestGuardState |= (1 << 7);
	break;
    case COMM_GSM_GUARD2:
	strcpylen(GSMMobileBuff[6], GSMCommBuff, MOBILE_DIGIT_LEN);
	TestGuardState |= (1 << 8);
	break;
    case COMM_GSM_GUARD3:
	strcpylen(GSMMobileBuff[7], GSMCommBuff, MOBILE_DIGIT_LEN);
	TestGuardState |= (1 << 9);
	break;
    }

    switch (GSMCommType) {
    case COMM_GSM_NAME:
    case COMM_GSM_CODE:
    case COMM_GSM_CARTEL:
    case COMM_GSM_CENTER:
    case COMM_GSM_MASTER:
    case COMM_GSM_HOSTER:
    case COMM_GSM_GUARD0:
    case COMM_GSM_GUARD1:
    case COMM_GSM_GUARD2:
    case COMM_GSM_GUARD3:
	if (TestGuardCount && TestGuardTimer) {
	    TestGuardCount--;
	    if (TestGuardCount == 0) {
		TestGuardOK = (TestGuardState == 0x3FF);
		MapShowGuard();
	    }
	    else {
		TestGuardTimer = 1500;
		DSASendGSM(COMM_GPS_SET);
	    }

#ifdef MONITOR_HARDWARE_TEST
	    psprintf(LineBuffer, "GUARD : %02x", TestGuardCount);
	    MenuPrintMessage(3);
#endif
	}
	break;
    }
}
#endif

#ifdef SUPPORT_DBUS_FUNCTION
void DSASendMessage()
{
    BYTE		i;
    BYTE		XorSum;
    BYTE		Length;

    XorSum = 0;
    Length = strlen(GBusMessageText) + (GBUS_MESSAGE_SIZE - GBUS_MESSAGE_TEXT_SIZE);