mn80comm.c

phs 源代码 小灵通协议源代码 phs source code

#ifndef PM_ONPC


#ifdef __cplusplus
extern "C"{
#endif
#include	"phs_def.h"

//  #pragma	section	area m_data
#include	"mn80.h"
#include	"mn80ext.h"

//  #pragma	section	code mp_code

#ifdef SIMU_ON_PC
	#include "simu_define.h"
#endif

void Mn_PCCHEstablish(void)	//PM -> MN
{
	U1	i;
	M_MSB *pMsg ;

	pMsg = MN_IN_EVT(PM_MN_EVT)->msg_adr;

	if(pMsg->msg[2] != 0x02)
	{
		ReaVal = PRIERR;
		err_dsp(pMsg);
		return;
	}

	if (CsyncTim[!phs_mode] || CCHShortTim[!phs_mode])
	{

		pMsg->msg[1] = MCCHMIS;
		pMsg->msg[2] = 0x05;
		pMsg->msg[3] = BIT7+BIT3;		//state
		pMsg->msg[4] = IREASON;
		pMsg->msg[5] = 0x02;
		pMsg->msg[6] = 0x03;
		pMsg->msg[7] = 0x07;			//reason value

		exec_uap(pMsg);
		return;
	}

	for (i = 0; i < 3; i++)
	{
		SysStsTim[phs_mode][i] = 0;
	}
	RetryCount = 0;
	move_up_b(TriedPBSid, CLSCSID, 6);
	CCHFact[PHS_PUBLIC_STS] = CCHEST;
	if (RegulCS[phs_mode].Kind)
	{
		move_up_b(PBSid, (U1*)RegulCS[phs_mode].Csid, 6);

	}
	else
	{
		move_up_b(PBSid, CLSCSID, 6);
	}

	WaitCS[PHS_PUBLIC_STS].CCHno = Sys_carrier[2];
	if (!WaitCS[PHS_PUBLIC_STS].CCHno)
	{
		pMsg->msg[1] = MCCHMIS;				//CCH  failed
		pMsg->msg[2] = 0x05;
		pMsg->msg[3] = BIT7+BIT3;				//state
		pMsg->msg[4] = IREASON;
		pMsg->msg[5] = 0x02;
		pMsg->msg[6] = 0x03;
		pMsg->msg[7] = 0x1F;					//the value of reason
		exec_uap(pMsg);						//Send to PM

		Sleep_Control(BSLPFORV);

		#ifdef PROT_TEST
		HisOut(0x00,0xfe,0x02,0x00,0x00);
		#endif

		if (CCHInfo.Main != 0xFF)
		{
			return;
		}
		slp_t_req(0xffff,0);
		ph_ini_req();
		return;
	}

	Mn_state.public_mod = ST_PP_CCH_MON;
#ifdef SIMU_ON_PC
	SendUart2L1( SIMTSKDTW , MNSTATE , 0 , (BYTE*)&Mn_state.public_mod , 1);
#endif
	EstRetry = ON;
	moni_cnt = 0;

	m_frebuf((U1*)pMsg);

	Mn_PCsyncCounterClear();
	Mn_CCH_M_REQ(ON);
}



void Mn_CCH_M_REQ(U1 flg)
{

	U1	WaitSlvl;

	CCHGain = LOW;

	if((CCHFact[PHS_PUBLIC_STS] == CCHCAL) || (CCHFact[PHS_PUBLIC_STS] == CCHINC))
		WaitSlvl = Sys_pbsid[8];
	else
		WaitSlvl = Sys_pbsid[7];

	cch_m_req(CCHEST, (U1)(WaitCS[phs_mode].CCHno-1),WaitSlvl,CCHGain,OFF);
	Mn_settim(TICCHMON);
	CCHInfo.Moni = phs_mode;
	CCHMonReg = 0;

}



void Mn_PCCHFail(void)
{
	CCHInfo.Moni = 0xFF;

	Mn_PCCHTimStp(phs_mode);

	if (CCHFact[phs_mode] != CCHEST)
	{
		Mn_PRadioInit();
		return;
	}



	if (phs_mode == CallChanel)
	{
		CallChanel = 0xFF;
	}
	RetryCount = 0;
	move_up_b(TriedPBSid, CLSCSID, 6);
	if(EstRetry)
	{
		EstRetry --;
		Mn_PCCHTimStp(PHS_PUBLIC_STS);
#ifdef  _DEBUG_TC6_
		_SendStringToUart("PCCHFAIL\n",sizeof("PCCHFAIL\n"));
#endif
		if(Mn_PBSSelReTry(CCHFact[PHS_PUBLIC_STS]) != NG)
			return;
	}

	Mn_CCHMisInit();

}



void Mn_CCHMisInit(void)
{
	U1	fmode;
#ifdef	EXT_IO
	U1	mnghis[6];
#endif
	U1	*p;

	fmode = !phs_mode;

	SYS_WORK->msg_adr = (M_MSB*)m_hntbuf();
	SYS_WORK->msg_adr->msg[0] = OPUBLIC;
	SYS_WORK->msg_adr->msg[1] = MCCHMIS;
	SYS_WORK->msg_adr->msg[2] = 0x05;
	SYS_WORK->msg_adr->msg[3] = BIT7+BIT3;
	SYS_WORK->msg_adr->msg[4] = IREASON;
	SYS_WORK->msg_adr->msg[5] = 0x02;
	SYS_WORK->msg_adr->msg[6] = 0x03;
	SYS_WORK->msg_adr->msg[7] = ReaVal;

	exec_uap(SYS_WORK->msg_adr);

	CCHInfo.Main = 0xFF;
	slp_t_req(0xffff,0);

	ph_ini_req();

	Sleep_Control(BSLPFORV);

	#ifdef PROT_TEST
		HisOut(0x00,0xfe,0x03,0x00,0x00);
	#endif

	p = Mn_GetSpecState(phs_mode);
	if(NULL == p)
		return;

	*p = ST_PP_IDLE;
#ifdef SIMU_ON_PC
	if(PHS_PUBLIC_STS == phs_mode)
		SendUart2L1( SIMTSKDTW , MNSTATE , 0 , (BYTE*)&Mn_state.public_mod , 1);
#endif

	CCHFact[phs_mode] = 0xFF;

#ifdef	EXT_IO
	mnghis[0] = phs_mode;
	mnghis[1] = Mn_state.common_mod;
	mnghis[2] = Mn_state.public_mod;
	mnghis[3] = Mn_state.private_mod;
	mnghis[4] = Mn_state.ps2ps_mod;
	mnghis[5] = ReaVal;

	HisOut(6 , 0x4e , Mn_InEvtCod[0] , Mn_InEvtCod[1] , mnghis);
#endif
}



void Mn_PCCHLiberate(void)
{
	U1	fmode;
	U1	*p;

	fmode = !phs_mode;

	Mn_PCCHTimStp(phs_mode);


	if( MN_IN_EVT(PM_MN_EVT)->msg_adr->msg[2] )	//
	{
		ReaVal = PRIERR;
		err_dsp( MN_IN_EVT(PM_MN_EVT)->msg_adr );
		return;
	}

	m_frebuf((U1*)MN_IN_EVT(PM_MN_EVT)->msg_adr);

	if (phs_mode == CallChanel)
	{
		CallChanel = 0xFF;
	}


	p = Mn_GetSpecState(phs_mode);
	if(NULL == p)
		return;

	if(ST_PP_CCH_MON == *p)
	{
		cch_m_stp();
		m_stptim(T20MS, TICCHMON, phs_mode);
		CCHInfo.Moni = 0xFF;
		CCHMonReg = 0;
	}
	CCHInfo.Main = 0xFF;
	slp_t_req(0xffff,0);
	ph_ini_req();
	Sleep_Control(BSLPFORV);

	#ifdef PROT_TEST
		HisOut(0x00,0xfe,0x04,0x00,0x00);
	#endif

	*p = ST_PP_IDLE;			//Change state

#ifdef SIMU_ON_PC
	if(PHS_PUBLIC_STS == phs_mode)
		SendUart2L1( SIMTSKDTW , MNSTATE , 0, (BYTE*)&Mn_state.public_mod , 1);
#endif
}


extern  void _SendStringToUart(U1*,U2 );
void Mn_PCCHTimUp(void)		//Timer event
{
#ifdef	EXT_IO
	U1	mnghis[6];
#endif






	switch(Mn_InEvtCod[0])
	{
	case	TICSYNC:
        //Debug By Chenwei
    //    ProtocolTrace(2,"!!TI time out\n");
		CsyncTim[phs_mode] = OFF;
		ReaVal = 0x02;
		if((phs_mode == PHS_PUBLIC_STS) &&
			(Mn_state.public_mod==ST_PP_REPORT || Mn_state.public_mod==ST_PP_WAIT))
		{
	 		Short_chakko = OFF;
			PubNgAreaClr();

		}
		HisOut(0,0xd6,0x03,0,0);
		Mn_PCCHFail();
		return;
	break;
	case	TICCHSHT:
		CCHShortTim[phs_mode] = OFF;
		ReaVal = 0x1F;
	break;
	case	TICCHEST:
		CCHEstTim[phs_mode] = OFF;
		cch_m_stp();
		ReaVal = 0x06;
	break;
	default	:
		return;
	}

	if(phs_mode == PHS_PUBLIC_STS)
	{
		if(Mn_state.public_mod==ST_PP_REPORT || Mn_state.public_mod==ST_PP_WAIT)
		{
			switch(Mn_InEvtCod[0])
			{
				case TICCHEST:
				case TICSYNC:
				case TICCHSHT:
					PubNgAreaClr();
				break;
			}
		}
	}

	if (phs_mode == CallChanel)
	{
		CallChanel = 0xFF;
	}
	Mn_PCCHTimStp(phs_mode);

	Mn_PCsyncCounterClear();

	if ((phs_mode == PHS_PUBLIC_STS) && RetryCount
			&& (CCHFact[phs_mode] == CCHINC || CCHFact[phs_mode] == CCHCAL))
	{
		Mn_PRadioInit();
		return;
	}



	if (( phs_mode == PHS_PUBLIC_STS ) && ( Call_Loc_flg == OFF ))
	{

		if( (CCHFact[PHS_PUBLIC_STS] == CCHLOC) && (Mn_InEvtCod[0] == TICCHEST) )
		{
			ph_ini_req();
			if (Mn_PBSSelReTry(CCHLOC) != NG)
			{
				CallChanel = PHS_PUBLIC_STS;
				return;
			}
		}
	}
	if(EstRetry)
	{
		EstRetry --;
		Mn_PBSRetryCheck();
		return;
	}

	Mn_CCHMisInit();

}



void Mn_PCCHReEstab(void)
{
	U1	fmode;
	U1	*p;


	fmode = !phs_mode;

	if (phs_mode == CallChanel)
	{
		CallChanel = 0xFF;
	}
	Mn_PCCHTimStp(phs_mode);

	Mn_PCsyncCounterClear();

	if(0x02 != MN_IN_EVT(PM_MN_EVT)->msg_adr->msg[2])
	{
		ReaVal = PRIERR;
		err_dsp( MN_IN_EVT(PM_MN_EVT)->msg_adr );
		return;
	}

	m_frebuf((U1*)MN_IN_EVT(PM_MN_EVT)->msg_adr);

	CCHInfo.Main = 0xFF;
	slp_t_req(0xffff,0);
	ph_ini_req();

	p = Mn_GetSpecState(phs_mode);
	if(NULL == p)
		return;
	if(ST_PP_WAIT == *p)
	{
		*p = ST_PP_CCH_MON;
	}
	else
		(*p)--;

#ifdef SIMU_ON_PC
	if(PHS_PUBLIC_STS == phs_mode)
		SendUart2L1( SIMTSKDTW , MNSTATE , 0, (BYTE*)&Mn_state.public_mod , 1);
#endif

	Mn_CCH_M_REQ(ON);
}


void Mn_PCCHTimStp(U1 mode)
{
	if (RetryTim)
	{
		m_stptim(T20MS, TIRETRY, PHS_PUBLIC_STS);
		RetryTim = OFF;
	}
	if (CCHShortTim[mode])
	{
		m_stptim(T1S, TICCHSHT, mode);
		CCHShortTim[mode] = OFF;
	}
	if (CCHEstTim[mode])
	{
		m_stptim(T100MS, TICCHEST, mode);
		CCHEstTim[mode] = OFF;
	}
	if (CsyncTim[mode])
	{
		m_stptim(T100MS, TICSYNC, mode);
		CsyncTim[mode] = OFF;
	}
	if (CCHInfo.Moni == phs_mode)
	{
		CCHInfo.Moni = 0xFF;
	}
	if (!(WReMonTimN & BIT8))
	{
		if ( WReMonTim & BIT1 )
		{
			m_stptim(T1S, TIWMONIT1, PHS_PUBLIC_STS);
			WReMonTim = 0;
			WReMonTimN = 0;
		}
	}
	if ( WPubMon == ON )
	{
		m_stptim(T20MS, TICCHMON, PHS_PUBLIC_STS);
		cch_m_stp2();
		CCHInfo.Moni = 0xFF;
		WPubMon = OFF;
#ifdef SIMU_ON_PC
		SendUart2L1(SIMTSKDTW , WPUBMON , 0 , &WPubMon , 1);
#endif
		WReMonTimN = 0;
	}
}


void Mn_PCsyncOut(void)
{
	U1	*p;

#ifdef  _DEBUG_TC6_
		_SendStringToUart("Mn_PCsyncOut\n",sizeof("Mn_PCsyncOut\n"));
#endif

#ifdef PROT_TEST
HisOut(0x00,0xff,0x01,SLEEP_STS[phs_mode],0x00);
#endif

	if (CCHEstTim[phs_mode])
	{
		m_stptim(T100MS, TICCHEST, phs_mode);
		CCHEstTim[phs_mode] = OFF;
		Mn_PCsyncCountStart();
	}

	switch(CCHFact[phs_mode])