dsa.c

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

    if (Length < GBUS_MESSAGE_SIZE)	Length++;
    DSASendData(COMM_BUS_MESSAGE, Length);
    for (i = 0; i < Length; i++) {
	DSASendData(i, GBusMessage[i]);
	XorSum ^= GBusMessage[i];
    }
    DSASendData(Length, XorSum);
}

void DSASendBusLine()
{
    BYTE		i;
    BYTE		XorSum;
    BYTE		Length;

    if (GBusLineSize) {
	XorSum = 0;
	Length = strlen(GBusLineList + GBusLineAddr * GBUS_SETLINE_SIZE);
	if (Length < GBUS_LINESET_SIZE)	Length++;
	DSASendData(COMM_BUS_SETLINE, Length);
	for (i = 0; i < Length; i++) {
	    DSASendData(i, GBusLineList[GBusLineAddr * GBUS_SETLINE_SIZE + i]);
	    XorSum ^= GBusLineList[GBusLineAddr * GBUS_SETLINE_SIZE + i];
	}
	DSASendData(Length, XorSum);
    }
}

void DSASendVCDDist()
{
    BYTE		i;
    BYTE		XorSum;

    XorSum = 0;
    DSASendData(COMM_BUS_VCDDIST, GBUS_VCDDIST_SIZE);
    for (i = 0; i < GBUS_VCDDIST_SIZE; i++) {
	DSASendData(i, DBusVCDDist[i]);
	XorSum ^= DBusVCDDist[i];
    }
    DSASendData(GBUS_VCDDIST_SIZE, XorSum);
}

void DSASendSoftVer()
{
    BYTE		i;
    BYTE		XorSum;
    BYTE		Length;

    XorSum = 0;
    Length = strlen(ProgramVer);
    if (Length < GBUS_SOFTVER_SIZE)	Length++;
    DSASendData(COMM_BUS_SOFTVER, Length);
    for (i = 0; i < Length; i++) {
	DSASendData(i, ProgramVer[i]);
	XorSum ^= ProgramVer[i];
    }
    DSASendData(Length, XorSum);
}
#endif

#define	GSM_SELF_TEST_DATA	0x5A
BYTE DSASelfTest()
{
    BYTE		i;

    TestDSAState = FALSE;

    for (i = 0; i < 3; i++) {
	TestDSATimer = 1500;
	DSASendData(COMM_BUS_INITGSM, ~GSM_SELF_TEST_DATA);
	while (TestDSATimer && !TestDSAState) {
	    polling();
	}
	if (TestDSAState)	break;
    }

    return TestDSAState;
}

#ifdef SUPPORT_GSM_GUARD
BYTE DSAGuardTest()
{
    TestGuardState = 0;
    TestGuardTimer = 800;

    DSASendGSM(COMM_GPS_SET);
    while (TestGuardTimer && !TestGuardState) {
	polling();
    }

    return TestGuardState;
}
#endif

#if 0	// SUPPORT_DSA_VERSION > 19
BYTE DSACheckCode()
{
    DSAEnCode = 0x5A;
    DSADeCode = 0x5A;

    psprintf(LineBuffer, "DSA En-Code : %02x", DSAEnCode);
    MenuPrintMessage(4);

    DSASendData(COMM_GET_PASSWORD, DSAEnCode);

    TestDSATimer = 200;
    while (TestDSATimer) {
	if (DSAEnCode != DSADeCode)	break;
	polling();
    }

    return (DSAEnCode != DSADeCode);
}

void DSAGetVersion(BYTE *String)
{
    if (DSAVerSoft) {
	Dec2Str(String, DSAVerSoft);
	if (DSAVerMisc & (1 << 6)) {
	    strncat(String, "A");
	}
	if (DSAVerMisc & (1 << 5)) {
	    strncat(String, "G");
	}
	if (DSAVerMisc & (1 << 4)) {
	    strncat(String, "B");
	}
	if (DSAVerMisc & (1 << 1)) {
	    strncat(String, "V");
	}
    }
    else {
	strcpy(String, "19");
    }
}
#endif

void DSATimer10mS()
{
    if (TestDSATimer)		TestDSATimer--;

#ifdef SUPPORT_GSM_GUARD
    if (TestGuardTimer)		TestGuardTimer--;
#endif
#ifdef SUPPORT_GPRS_CENTER
    if (DSASendGPRSTime)	DSASendGPRSTime--;
#endif
#ifdef SUPPORT_VCD_HOST
    if (VCDCommTimer)		VCDCommTimer--;
#endif

#ifdef MONITOR_HARDWARE_TEST
//  psprintf(LineBuffer, "%04x-%04x", (regs0->stc_15_0) & 0xFF, (regs0->stc_15_0) >> 8);
//  MenuPrintMessage(2);
#endif
}

#define	DSA_TIME_EXPIRED	(20)		// 20mS
void PollingDSA()
{
    if (DSAStep && DSABitTimer == 0) {
	if (DSASendFlag) {
	    FIFO_SEND_FO_BACK(DSADataBackup);
	}
	FinishDSA();
	return;
    }

    switch (DSAStep) {
    case 0x00:
	if (DSA_DAT_READ) {
#if defined(SUPPORT_GSM_GUARD) || defined(SUPPORT_GPRS_CENTER)
	    if (!FIFO_DATA_EMPTY && FIFO_SEND_EMPTY) {
		FIFO_DATA_FO(DSAData);
		FIFO_SEND_FI(DSAData);
	    }
	    else
#endif
	    if (!FIFO_SEND_EMPTY && DSATryCount == 0) {
		DSATryCount = 10;
		DSA_DAT_LOW;
		FIFO_SEND_FO(DSAData);
		DSADataBackup = DSAData;
		DSASendFlag = TRUE;
		DSAStep = 0x10;
	    }
	    else
	    if (DSATryCount) {
		DSATryCount--;
	    }
	}
	else {
	    DSA_ACK_LOW;
	    DSAStep = 0x20;
	}
	DSABitTimer = DSA_TIME_EXPIRED;
	return;
	break;

    case 0x10:
	if (DSA_ACK_READ)	return;
	DSA_DAT_HIGH;
	break;
    case 0x11:
	if (!DSA_ACK_READ)	return;
	if (DSAData & 0x8000) {	DSA_DAT_HIGH; }
	else		      {	DSA_DAT_LOW;  }
	DSA_STB_LOW;
	break;
    case 0x12:
	if (DSA_ACK_READ)	return;
	DSA_STB_HIGH;
	if (DSABitCount >= 15) {
	    DSABitCount = 0;
	    DSA_DAT_HIGH;
	    DSA_ACK_LOW;
	}
	else {
	    DSABitCount++;
	    DSAData <<= 1;
	    DSAStep = 0x10;
	}
	break;
    case 0x13:
	if (DSA_STB_READ)	return;
	DSA_ACK_HIGH;
	break;
    case 0x14:
	if (!DSA_STB_READ)	return;
#ifdef MONITOR_HARDWARE_TEST
	psprintf(LineBuffer, "DSAS : %04x", DSADataBackup);
	MenuPrintMessage(2);
#endif
	if (DSADataBackup == DSASendDataBackup) {
	    DSASendDoneFlag = TRUE;
	}
#if 0	// def SUPPORT_WINBOND_VOICE
	if (DSADataBackup == ((COMM_AV_SWITCH << 8) | SW_VIDEO_VCD | SW_AUDIO_VOICE)) {
	    SwitchVoiceDelay();
	}
#endif
	FinishDSA();
	return;

    case 0x20:
	if (!DSA_DAT_READ)	return;
	DSA_ACK_HIGH;
	break;
    case 0x21:
	if (DSA_STB_READ)	return;
	DSAData <<= 1;
	if (DSA_DAT_READ)	DSAData |= 0x01;
	DSA_ACK_LOW;
	break;
    case 0x22:
	if (!DSA_STB_READ)	return;
	DSA_ACK_HIGH;
	if (DSABitCount >= 15) {
	    DSABitCount = 0;
	    DSA_DAT_HIGH;
	}
	else {
	    DSABitCount++;
	    DSAStep = 0x20;
	}
	break;
    case 0x23:
	if (DSA_ACK_READ)	return;
	DSA_DAT_HIGH;
	DSA_STB_LOW;
	break;
    case 0x24:
	if (!DSA_ACK_READ)	return;
	FinishDSA();
	FIFO_RECV_FI(DSAData);
	return;
    }

    DSAStep++;
    DSABitTimer = DSA_TIME_EXPIRED;
}

/************************************************************************
 *	Communication Subroutine					*
 ************************************************************************/
void PollingDSAComm()
{
    UINT16		CommData;
    BYTE		Comm, Data;

    if (!FIFO_RECV_EMPTY) {
	FIFO_RECV_FO(CommData);
	Comm = CommData >> 8;
	Data = CommData & 0xFF;
#ifdef MONITOR_HARDWARE_TEST
	psprintf(LineBuffer, "DSAR : %04x", CommData);
	MenuPrintMessage(2);
#endif

#ifdef SUPPORT_DBUS_FUNCTION
	if (Comm <= COMM_ADDR_END) {
	    if (Comm == DSARecvSize) {
		if (DSARecvFlag && (DSARecvData ^ Data) == 0) {
		    DSARecvFlag = FALSE;
		    DBusMakeGPSData(DSARecvType);
		}
	    }
	    else
	    if (Comm == DSARecvNext) {
		DSACommBuff[Comm] = Data;
		DSARecvNext++;
		DSARecvData ^= Data;
	    }
	    else {
		DSARecvFlag = FALSE;
	    }
	    return;
	}
#endif

	switch (Comm) {
#ifdef SUPPORT_DBUS_FUNCTION
	case COMM_BUS_GPSINFO:
	case COMM_BUS_GPSTASK:
	case COMM_BUS_GPSCOME:
	case COMM_BUS_GPSAWAY:
	case COMM_BUS_GPSOVER:
	case COMM_BUS_GPSTAIL:
	case COMM_BUS_GPSLINE:
	case COMM_BUS_STATION:
	case COMM_BUS_SETLINE:
	case COMM_BUS_GPSTIME:
	case COMM_BUS_SOFTVER:
	    DSARecvFlag = TRUE;
	    DSARecvType = Comm;
	    DSARecvSize = Data;
	    DSARecvNext = 0;
	    DSARecvData = 0;
	    if (DSARecvSize == 0 || DSARecvSize > COMM_ADDR_END) {
		DSARecvFlag  = FALSE;
	    }
	    break;
	case COMM_BUS_TASKICQ:
	case COMM_BUS_TASKEND:
	case COMM_BUS_GPSMODE:
	case COMM_BUS_SETSIZE:
	case COMM_BUS_DIRLINE:
	case COMM_BUS_BUSLINE:
	    DSARecvFlag = FALSE;
	    DSACommBuff[0] = Data;
	    DBusMakeGPSData(Comm);
	    break;

	case COMM_BUS_INITGSM:
	    DSARecvFlag	 = FALSE;
	    GBusResetGSM = TRUE;
	    TestDSAState = (Data == GSM_SELF_TEST_DATA);
	    break;
	case COMM_BUS_INITGPS:
	    DSARecvFlag	 = FALSE;
	    GBusResetGPS = TRUE;
	    DSASendData(COMM_BUS_INITGPS, ~Data);
	    break;
#endif
	}
    }
}

#ifdef SUPPORT_TEST_FUNCTION
void TestDSA()
{
#if 0	// def SUPPORT_GSM_GUARD
    BYTE		i;

    StrToPDUText(UnicodeBuffer, (BYTE *)StrPosi);
    DSASendGSM((COMM_GPS_POSI << 8) | strlen(UnicodeBuffer));
    for (i = 0; i < strlen(UnicodeBuffer); i++) {
	DSASendGSM((i << 8) | UnicodeBuffer[i]);
    }
    DSASendGSM(COMM_ADDR_END << 8);

#if 0
//  4E3051CC75355668
    DSASendGSM('4' << 8 | 'E');
    DSASendGSM('3' << 8 | '0');
    DSASendGSM('5' << 8 | '1');
    DSASendGSM('C' << 8 | 'C');
    DSASendGSM('7' << 8 | '5');
    DSASendGSM('3' << 8 | '5');
    DSASendGSM('5' << 8 | '6');
    DSASendGSM('6' << 8 | '8');
#endif
#elif 0		// SUPPORT_DSA_VERSION > 19
    DSACheckCode();
#elif 0
    static BYTE		Count = 0;

//  DSAWriteByte(0x5a);
    DSAData = 0x5a00;
    psprintf(LineBuffer, "DSA Send : %02x-%02x", DSAData, Count++);
    MenuPrintMessage(2);
#endif
}
#endif SUPPORT_TEST_FUNCTION
#endif SUPPORT_DSA_DEVICE