mn80pub1.c

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

			{


				move_up_b((U1*)RegulCS[phs_mode].Csid, (U1*)WaitCS[phs_mode].Csid, 6);
				RegulCS[phs_mode].GrpFlg = WaitCS[phs_mode].GrpFlg;
				RegulCS[phs_mode].FreqNo = WaitCS[phs_mode].CCHno;
				RegulCS[phs_mode].Kind &= 0x02;
			}
			RegulCS[phs_mode].Kind |= 0x08;
		}
	}
	else
	{
 		j = PSNum[PHS_PUBLIC_STS] % 8 + 1;
		RegulCS[phs_mode].Kind &= ~0x0a;
		if (Sys_bcch[1][phs_mode][4] & (0x01 << (j-1)))
		{
			if (Sys_bcch[1][phs_mode][5] & BIT6)
			{
				if(cmp_up_b((U1*)RegulCS[phs_mode].Csid, (U1*)WaitCS[phs_mode].Csid, 6))
				{

					move_up_b((U1*)RegulCS[phs_mode].Csid,(U1*)WaitCS[phs_mode].Csid,6);
					RegulCS[phs_mode].GrpFlg = WaitCS[phs_mode].GrpFlg;
					RegulCS[phs_mode].FreqNo = WaitCS[phs_mode].CCHno;
					RegulCS[phs_mode].Kind = 0;
				}
				RegulCS[phs_mode].Kind |= 0x02;
			}
			if (Sys_bcch[1][phs_mode][5] & BIT5)
			{
				if(cmp_up_b((U1*)RegulCS[phs_mode].Csid, (U1*)WaitCS[phs_mode].Csid, 6))
				{

					move_up_b((U1*)RegulCS[phs_mode].Csid,(U1*)WaitCS[phs_mode].Csid,6);
					RegulCS[phs_mode].GrpFlg = WaitCS[phs_mode].GrpFlg;
					RegulCS[phs_mode].FreqNo = WaitCS[phs_mode].CCHno;
					RegulCS[phs_mode].Kind &= 0x02;
				}
				RegulCS[phs_mode].Kind |= 0x08;
			}
		}
	}
	if(cmp_up_b((U1*)RegulCS[phs_mode].Csid, (U1*)WaitCS[phs_mode].Csid, 6))
	{
		if(!(RegulCS[phs_mode].Kind & 0x0a))
		{
			if((RegulCS[phs_mode].Kind & 0x14))
				return;
			move_up_b((U1*)RegulCS[phs_mode].Csid,CLSCSID,6);
			RegulCS[phs_mode].GrpFlg = 0;
			RegulCS[phs_mode].FreqNo = 0;
			RegulCS[phs_mode].Kind = 0;
		}
	}
}



void Mn_PCCHEstComp(void)
{
	move_up_b(TriedPBSid, CLSCSID, 6);
#ifdef  _DEBUG_TC6_
		_SendStringToUart("PcchEst OK!\n",13);
#endif
	switch (CCHFact[phs_mode])
	{
	case CCHEST :
		Mn_PCCHEstCompWait();
		if(Short_chakko == ON)
		{
			Short_chakko = OFF;
			Mn_IncomCallDsp();
		}
	break;

	case CCHCAL :
	case CCHINC :
	case CCHLOC :
		Mn_PCCHEstCompLink();
	break;

	default :
		CCHFact[phs_mode] = CCHEST;
		ReaVal = 0x1F;
		Mn_PCCHFail();
	break;
	}
}



void Mn_PCCHEstCompWait(void)
{
	U1	n, i;

	A_short = OFF;
	A_count = 0;

	if(Short_chakko == OFF)
	{
		Sleep_Pch_Set((U1)Frame_cnt[phs_mode]);
	}



	SYS_WORK->msg_adr = (M_MSB*)m_hntbuf();

	SYS_WORK->msg_adr->msg[0] = OPUBLIC;
	SYS_WORK->msg_adr->msg[1] = MCCHEST;
	EstRetry = OFF;
	set_up_b(Sys_napbs[PHS_PUBLIC_STS], 0, 6);

	Sys_pbsid[6] = Sys_prinfo[2] & 0x0f;
	Mn_PAreaBitMask();
	LocInf[PHS_PUBLIC_STS].CompFlg = ON	;
	LocInf[PHS_PUBLIC_STS].GrpFlg = WaitCS[PHS_PUBLIC_STS].GrpFlg;
	LocInf[PHS_PUBLIC_STS].FrqNo = WaitCS[PHS_PUBLIC_STS].CCHno;
	if(exe_reg_cs_id == 1)
	{
		LocInf[PHS_PUBLIC_STS].CompFlg = OFF;
		exe_reg_cs_id = 0;
		reg_fail = ON;
	}
	else
	{
		if (WaitCS[PHS_PUBLIC_STS].Csid[0] != Sys_pbsid[0]
			|| (WaitCS[PHS_PUBLIC_STS].Csid[1] & 0x80) != (Sys_pbsid[1] & 0x80)
			|| (Mn_AreaNoCmp((U1*)WaitCS[PHS_PUBLIC_STS].Csid) == OFF))
		{
			LocInf[PHS_PUBLIC_STS].CompFlg = OFF;
		}
		if(reg_fail == ON)
			LocInf[PHS_PUBLIC_STS].CompFlg = OFF;
	}

	SYS_WORK->msg_adr->msg[3] = (LocInf[PHS_PUBLIC_STS].CompFlg ? 0:1);


	SYS_WORK->msg_adr->msg[5] = (WaitCS[PHS_PUBLIC_STS].GrpFlg ? BIT1 : BIT5);


	if ( !cmp_up_b((U1*)WaitCS[phs_mode].Csid, (U1*)RegulCS[phs_mode].Csid, 6)
		&& (RegulCS[phs_mode].Kind & 0x06) && !AccTimLoc[phs_mode])
	{

		if (!(Sys_pri & BIT1) && ACCYCINT(phs_mode))
		{
			Mn_settim(TIACLOC);
			RegulCS[phs_mode].Kind |= 0x04;
		}
	}

	SYS_WORK->msg_adr->msg[4] = 0x00;

	move_up_b((U1*)&SYS_WORK->msg_adr->msg[6] , (U1*)WaitCS[phs_mode].Csid , 6);

	move_up_b(SYS_CSID_P, (U1*)WaitCS[phs_mode].Csid, 6);	//Add by Qian Aidong 2002-05-10
													 //When under field test mode, if PS is in idle state,
													 //the CSID can't update automatic.

	SYS_WORK->msg_adr->msg[12] = (Sys_bcch[0][phs_mode][2] & 0x0F);

	n = 13;
	if (SysInfFlag[phs_mode][0] == ON)
	{

		SYS_WORK->msg_adr->msg[n] = ISYSINF;
		move_up_b((U1*)&SYS_WORK->msg_adr->msg[n+1] , &Sys_bcch[1][phs_mode][1] , 7);
		n += 8;
	}
	if (SysInfFlag[phs_mode][1] == ON)
	{

		SYS_WORK->msg_adr->msg[n] = ISY2INF;

		move_up_b((U1*)&SYS_WORK->msg_adr->msg[n+1] , &Sys_bcch[2][phs_mode][1] , 7);
		n += 8;
	}
	if (SysInfFlag[phs_mode][2] == ON)
	{

		SYS_WORK->msg_adr->msg[n] = ISY3INF;

		move_up_b((U1*)&SYS_WORK->msg_adr->msg[n+1] , &Sys_bcch[3][phs_mode][1] , 7);
		n += 8;
	}

	SYS_WORK->msg_adr->msg[n++] = IRGLINF;

	SYS_WORK->msg_adr->msg[n] = 0;
	if ((phs_mode == PHS_PUBLIC_STS) && (RegulCS[phs_mode].Kind & 0x07))
	{
		SYS_WORK->msg_adr->msg[n] = (BIT8 | (RegulCS[phs_mode].Kind & 0x07));
	}
	for (i = 0; i < 6; i++)
	{
		if ((WaitCS[PHS_PUBLIC_STS].Csid[i] ^ LocNgCS[i]) & BitMask[i])
			break;
	}
	if ((i >= 6) && !Ich_Fail)
	{
		SYS_WORK->msg_adr->msg[n] |= BIT7;
	}
	else
		Ich_Fail = OFF;

	SYS_WORK->msg_adr->msg[2] = n-2;

	exec_uap(SYS_WORK->msg_adr);

	WReMonTimN |= BIT8;
	Mn_PCCHTimStp(phs_mode);
	WReMonTimN &= ~BIT8;

	if (CCHInfo.Main != !phs_mode)
	{
		CCHInfo.Main = phs_mode;
	}

	*Mn_GetSpecState(phs_mode) = ST_PP_WAIT;

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


}



void Mn_PCCHEstCompLink(void)
{
	U1	fmode;

	fmode = !phs_mode;

	if ( CCHFact[phs_mode] == CCHCAL )
	{

		if ( Mn_PUBCallReglChk() != OK )
		{
			Mn_PBSRetryCheck();
			return;
		}
	}
	if(Mn_EstCallLoc())
		return;

	if (( CCHFact[PHS_PUBLIC_STS] == CCHLOC )
		&& ( Call_Loc_flg == OFF ))
	{
		if ( Mn_PLocReglChk() == NG )
		{
#ifdef  _DEBUG_TC6_
		_SendStringToUart("PCCHESTCMPLNK\n",sizeof("PCCHESTCMPLNK\n"));
#endif
			if ( Mn_PBSSelReTry(CCHLOC) != NG )
			{
				return;
			}
			else
			{
				Mn_PRadioInit();
				return;
			}
		}
		WReMonTimN |= BIT8;
	}



	Mn_SysCsInfSet();

	Mn_PCCHTimStp(phs_mode);

	if (CCHInfo.Main != !phs_mode)
	{
		CCHInfo.Main = phs_mode;
	}

	*Mn_GetSpecState((BYTE)!phs_mode) = ST_PP_IDLE;
#ifdef SIMU_ON_PC
		if( PHS_PUBLIC_STS == (!phs_mode) )	//Note: Here is !phs_mode
			SendUart2L1( SIMTSKDTW , MNSTATE , 0 , (BYTE*)&Mn_state.public_mod , 1);
#endif


	Mn_PCCHTimStp(fmode);

	Sleep_Control(BSLPREL);
	#ifdef PROT_TEST
		HisOut(0x00,0xfe,0x08,0x00,0x00);
	#endif

	if (CCHFact[phs_mode] == CCHCAL)
	{
		MaxLCHCnt = 4;
		Mn_LCHMsgSet( CALLMODE_OUT);

		*Mn_GetSpecState(phs_mode) = ST_PP_LCH_EST_O;

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

	}
	else if (CCHFact[phs_mode] == CCHINC)
	{
		Mn_LCHMsgSet( CALLMODE_IN);

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

	}
	else if (CCHFact[PHS_PUBLIC_STS] == CCHLOC)
	{
		if (Sys_initdl1[17] && Call_Loc_flg == OFF)

		{
			MaxLCHCnt = 4;
			Mn_LCHMsgSet(CALLMODE_LOCREG);

			Mn_state.public_mod = ST_PP_LCH_EST_L;

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


		}
		WReMonTimN &= ~BIT8;

	}
	m_excreq((WORD*)&SYS_WORK->tsk_id);

	CCHFact[phs_mode] = 0xFF;
}



U1 Mn_PUBCallReglChk(void)
{
	if(RegulCS[PHS_PUBLIC_STS].Kind & 0x18)
	{
		if (RegulCS[PHS_PUBLIC_STS].Kind & 0x08)
		{
			if (AccTimCall[PHS_PUBLIC_STS])
			{
				m_stptim(T100MS, TIACCALL, PHS_PUBLIC_STS);
				AccTimCall[PHS_PUBLIC_STS] = OFF;
			}
			if (!Sys_pri && ACCYCINT(PHS_PUBLIC_STS))
			{
				Mn_settim(TIACCALL);
				RegulCS[PHS_PUBLIC_STS].Kind |= 0x10;
			}
		}
		return ( NG );
	}
	if ((CallKind & 0x20) && (Sys_ccsinf[19] == 0x01))
	{
		return ( NG_FF );
	}

	return ( OK );
}


void	Mn_Retry(void)
{
	if ( RetryCount == MAX_RETRY )
	{
		RetryCount --;
		Mn_PCsyncCounterClear();
		moni_cnt = 0;
		Mn_PPBSReSelect();
	}
	else
	{
		Mn_PBSRetryCheck();
	}
}

/****************************************************************************/
/*                                                                          */
/*      Function    U1 Mn_GetFeature(U1 feature, U1 sub-feature)          */
/*      PARAM       feature, sub-feature                                    */
/*      FUNC        return whether the feature is configured on or off      */
/*      RETURN      On - 1 ; Off - 0  										*/
/*      GLOBAL      Sys_initdl1[36]                                                        */
/*                                                                          */
/****************************************************************************/
U1 Mn_GetFeature(U1 feature, U1 subfeature)
{
	if(feature == FEATURE_SEAMLESS)
	{
		switch(subfeature)
		{
		case FEATURE_POWER_OFF_REG:
			return (Sys_initdl1[36]&FEATURE_POWER_OFF_REG) ;
		case FEATURE_LOW_CS_PREFER:
			return (Sys_initdl1[36]&FEATURE_LOW_CS_PREFER) ;
		default:
			return 0;
		}
	}

	return 0;
}

U1 GetPowerOffReg()
{
	return Mn_GetFeature(1,1);
}




void Mn_PCCHMonTo(void)
{
#if 1
	U1	n;

	CCHInfo.Moni = 0xFF;
	cch_m_stp();

	Mn_PCCHMonitor2();

	Ich_end_monF = OFF;
	if(!Mn_CCHMoniNG())
		return;
	for (n = 0; n < CCHMonReg; n++)
	{
		if (CCHMonTable[n].Rssi != 0xFF)
		{
			continue;
		}
		CCHMonTable[n].Rssi = 0x72;
	}
	if(Mn_GetFeature(FEATURE_SEAMLESS,FEATURE_LOW_CS_PREFER))
		Mn_LowCSPrefer_Sort(0); /*Not in standy mode, no prefer CS*/
	else
		Mn_RSSIMonRegSet();
#ifdef	EXT_IO
	HisOut(0,0x00,CCHMonReg,0,0);
	for (n = 0; n < CCHMonReg; n++)
	{
		HisOut(6,0x42,0,CCHMonTable[n].Rssi,(U1*)&CCHMonTable[n].Csid[0]);
	}
#endif

	if(Mn_PFstPBSCCHEstReqInit() == NG)
		Mn_MoveCCHFail();
#endif
}

U1	Mn_CCHMoniNG(void)
{
	if(CCHMonReg)
		return(1);

	if(!In_AreaMonitor)
		moni_cnt++;
	if(!moni_cnt)
	{
		moni_cnt++;
		Mn_CCH_M_REQ(OFF);
		In_AreaMonitor = OFF;

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

	}
	else
		Mn_MoveCCHFail();

	return(0);
}

void	Mn_MoveCCHFail(void)
{
	moni_cnt = 0;
	if(RetryCount)
		RetryCount = 1;
	if (ReaVal == 0)
		ReaVal = 0x1F;
	Mn_PCCHFail();
}

#ifdef __cplusplus
}
#endif

#endif