mn80comm.c

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

	{
	case	CCHINC:
	case	CCHCAL:
	case	CCHLOC:
		if(Mn_InEvtCod[0] == ESCCH &&  Mn_InEvtCod[1] != L1_NULL)
		{
			if(Mn_PCCHReEstComp())
				return;
		}
	}

	if(!(Sys_initdl1[24] & SLEEP_MASK))
	{
		Mn_PSELRSSIChk();
		return;
	}
	if (RadioFlag[phs_mode])
	{
		if( !(ESCCH == Mn_InEvtCod[0] && L1_NULL == Mn_InEvtCod[1]) )
			Mn_PCsyncTimStart();
		return;
	}



	Mn_PCsyncCount();

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

	if ( SLEEP_STS[phs_mode] == OFF )
	{
		if(ST_PP_WAIT == *p)
		{
			Sleep_Control(BSLPFORV);
	#ifdef PROT_TEST
		HisOut(0x00,0xfe,0x05,0x01,0x00);
	#endif
		}
	}
	else
	{
		if( (Mn_InEvtCod[0] == ESCCH) && (Mn_InEvtCod[1] == L1_NULL) )
		{
			if(ST_PP_WAIT == *p)
			{
				Sleep_Control(BSLPFORV);
	#ifdef PROT_TEST
		HisOut(0x00,0xfe,0x05,0x02,0x00);
	#endif
				Mn_UwCrcErrChk();
				Mn_CCHQualDsp();
			}
		}
		else
		{
			ReaVal = 0x02;
			Mn_PCCHFail();
		}
	}
}


void Mn_PCsyncTimStart(void)
{
	if (CsyncTim[phs_mode])
	{
		m_stptim(T100MS, TICSYNC, phs_mode);
		CsyncTim[phs_mode] = OFF;
	}
	if ((SLEEP_STS[phs_mode] == OFF) || RadioFlag[phs_mode])
	{

		Mn_settim(TICSYNC);
	}
	CsyncCount[phs_mode] = Sys_csynctim[phs_mode];
	UwCrc_Err = 0;

}


void	Mn_PCsyncCount(void)
{
	if(CsyncCount[phs_mode] <= 1)
	{
		SYS_WORK->tsk_id = TASKMNG;

		MN_OUT_EVT(MN_TIMER_EVT)->tim_id = TICSYNC;

		MN_OUT_EVT(MN_TIMER_EVT)->tim_info[0] = phs_mode;

		m_excreq((WORD*)&SYS_WORK->tsk_id);
		HisOut(0,0xd6,0x06,0,0);
		A_count = 0;
	}
	else
	{
		CsyncCount[phs_mode] --;
	}
}


void Mn_PCsyncCounterClear(void)
{
	if (CsyncTim[phs_mode])
	{
		m_stptim(T100MS, TICSYNC, phs_mode);
		CsyncTim[phs_mode] = OFF;
	}
	CsyncCount[phs_mode] = Sys_csynctim[phs_mode];
	UwCrc_Err = 0;

}


void Mn_PCsyncTimerClear(void)
{
	if (CsyncTim[phs_mode])
	{
		m_stptim(T100MS, TICSYNC, phs_mode);
		CsyncTim[phs_mode] = OFF;
	}
}


void Mn_PCsyncCountStart(void)
{
	if (CsyncTim[phs_mode])
	{
		m_stptim(T100MS, TICSYNC, phs_mode);
	}
	Mn_settim(TICSYNC);

	CsyncCount[phs_mode] = Sys_csynctim[phs_mode];
	UwCrc_Err = 0;
}


void Mn_PCsyncRssiChk(void)
{


#ifdef  _DEBUG_TC6_
		_SendStringToUart("Mn_PCsyncRssiChk\n",sizeof("Mn_PCsyncRssiChk\n"));
#endif
	if (CCHEstTim[phs_mode])
	{
		m_stptim(T100MS, TICCHEST, phs_mode);
		CCHEstTim[phs_mode] = OFF;
		Mn_PCsyncCountStart();
	}

	Mn_PCsyncTimStart();

	Mn_PSELRSSIChk();
}

void Mn_CCHQualDsp(void)
{

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

	SYS_WORK->msg_adr->msg[0] = OPUBLIC;
	SYS_WORK->msg_adr->msg[1] = MCCHQUAL;			//CCH quality
	SYS_WORK->msg_adr->msg[2] = 0x04;					//fixup = 4
	SYS_WORK->msg_adr->msg[3] = 0x00;					//public
	SYS_WORK->msg_adr->msg[4] = OFF;					//Public FER
	SYS_WORK->msg_adr->msg[5] = 0x00;					//Private average RSSI value
	SYS_WORK->msg_adr->msg[6] = OFF;					//PrivateFER

	SYS_WORK->msg_adr->msg[3] = ClvlSum[PHS_PUBLIC_STS];
	SYS_WORK->msg_adr->msg[4] = UwCrc_Err;

	exec_uap(SYS_WORK->msg_adr);
}


void Mn_CCHMonRegSet2(CCH_MON_INF *moni)
{
	U1	n;
	MN_CCHMONREC	*moni_tbl;
	U1	rssi = 0xFF;
	U1	min = 0;

	for (n = 0, moni_tbl = CCHMonTable; n < CCHMonReg; n++, moni_tbl++)
	{

		if (!cmp_up_b((U1*)moni_tbl->Csid, (U1*)moni->Csid, 6))
		{

			if ((moni->Rssi != 0xFF)
				&& (moni_tbl->Rssi < moni->Rssi || moni_tbl->Rssi == 0xFF))
			{
				moni_tbl->Rssi = moni->Rssi;
				moni_tbl->Gain = CCHGain;
			}
			return;
		}
		if (rssi > moni_tbl->Rssi)
		{
			rssi = moni_tbl->Rssi;
			min = n;
		}
	}

	if (CCHMonReg < 20)
	{

		move_up_b((U1*)moni_tbl->Csid, (U1*)moni->Csid, 6);
		moni_tbl->Rssi = moni->Rssi;
		moni_tbl->Gain = CCHGain;
		moni_tbl->Endflg = 0x00;
		moni_tbl->Locflg = 0x00;
		moni_tbl->GrpFlg = ON;
		CCHMonReg++;
	}
	else
	{
		if ((moni->Rssi == 0xFF) ||
			(moni->Rssi <= rssi))
		{
			return;
		}

		moni_tbl = &CCHMonTable[min];
		move_up_b((U1*)moni_tbl->Csid, (U1*)moni->Csid, 6);
		moni_tbl->Rssi = moni->Rssi;
		moni_tbl->Gain = CCHGain;
	}
}


void Mn_RSSIMonRegSet(void)
{
	U1				i, j, k;
	MN_CCHMONREC	CSWork;

	for ( i = 0; i < CCHMonReg - 1; i++ )
	{
		move_up_b((U1*)&CSWork, (U1*)&CCHMonTable[i], sizeof(MN_CCHMONREC));
		k = i;

		for ( j = i + 1; j < CCHMonReg; j++ )
		{
			if ( CCHMonTable[j].Rssi > CSWork.Rssi )
			{
				move_up_b((U1*)&CSWork, (U1*)&CCHMonTable[j],
													sizeof(MN_CCHMONREC));
				k = j ;
			}
		}

		move_up_b((U1*)&CCHMonTable[k], (U1*)&CCHMonTable[i],
												 sizeof(MN_CCHMONREC));
		move_up_b((U1*)&CCHMonTable[i], (U1*)&CSWork, sizeof(MN_CCHMONREC));
	}
}


U1	Mn_PPsnoCmp(void)
{
	U1	n;
	U1	psno;

	Sys_cch[0] &= 0x7f;
	if ((Sys_cch[0] & 0x70) == BCD13)
	{
		for (n = 0; n < 7; n++)
		{
			if ((Sys_cch[n] & 0xF0) == (Sys_psno[n] & 0xF0))
			{

				if ((Sys_cch[n] & 0xF0) == 0x00)
				{
					return (ON);
				}
			}
			else
			{
				return (OFF);
			}
			if ((Sys_cch[n] & 0x0F) == (Sys_psno[n] & 0x0F))
			{

				if ((Sys_cch[n] & 0x0F) == 0x00)
				{
					return (ON);
				}
			}
			else
			{
				return (OFF);
			}
		}
	}
	else if (((Sys_cch[0] & 0x70) == BCD13K)
			&& (Sys_ccsinf[19] >= 0x04))
	{
		for (n = 1; n < 7; n++)
		{
			psno = (Sys_cch[n-1] & 0x0F) << 4;
			if (psno != (Sys_psno[n] & 0xF0))
				return (OFF);
			else if (psno == 0x00)
				return (ON);

			psno = (Sys_cch[n] & 0xF0) >> 4;
			if (psno != (Sys_psno[n] & 0x0F))
				return (OFF);
			else if (psno == 0x00)
				return (ON);
		}
		if ((Sys_cch[6] & 0x0F) == 0x00)
			return (ON);
		else
			return (OFF);
	}
	else
	{
		return (OFF);
	}
	return (ON);
}


void	Mn_SysCsInfSet(void)
{
	U1	ver;

	Sys_ccsinf[3] = WaitCS[phs_mode].CCHno;
	move_up_b(SYS_CSID_P, (U1*)WaitCS[phs_mode].Csid, 6);

	SYS_PARTNER = (WaitCS[phs_mode].GrpFlg ? DDI_PBS : RCR_PBS);

	Sys_ccsinf[11] = (Sys_prinfo[2] & 0x0F);
	if (cmp_up_b(SYS_AREA_P, CLSAREA, 7))
	{

		Sys_ccsinf[12] = CCHs_CSlev;
		Sys_ccsinf[13] = CCHh_CSlev;
		Sys_ccsinf[14] = TCHh_CSlev;
		Sys_ccsinf[15] = TCHs_CSlev;
	}
	ver = RtMmVer[phs_mode];
	if ( ver & 0x04 )
		Sys_ccsinf[19] = 0x04;
	else if ( ver & 0x02 )
		Sys_ccsinf[19] = 0x02;
	else
		Sys_ccsinf[19] = 0x01;

#ifdef SIMU_ON_PC
	SendUart2L1( SIMTSKDTW , SYSCCSINF , 3 , &Sys_ccsinf[3] , 17);	//From 3~19
#endif

}


void	Mn_LCHMsgSet(enumCALLMODE Mode)
{
	set_up_b( (U1*)SYS_WORK->out_evt , 0 , sizeof(SYS_WORK->out_evt));

	SYS_WORK->tsk_id = TASKRT;
	MN_OUT_EVT(RT_MN_LCHEVT)->evt_cod = ERT;
	MN_OUT_EVT(RT_MN_LCHEVT)->pri_cod = PRLCHEST;

	MN_OUT_EVT(RT_MN_LCHEVT)->msg_dat[0] = 1;
	MN_OUT_EVT(RT_MN_LCHEVT)->msg_dat[1] = ((Sys_bcch[1][phs_mode][1] & 0xFC) |
												(~(Sys_bcch[1][phs_mode][1]) & 0x03));
	MN_OUT_EVT(RT_MN_LCHEVT)->msg_dat[4] = 0x00;
	switch ( Mode )
	{
	case CALLMODE_OUT:		//Call out
		MN_OUT_EVT(RT_MN_LCHEVT)->msg_dat[2] = ((CallKind & 0x0F) ? 0x80 : 0x00);
		MN_OUT_EVT(RT_MN_LCHEVT)->msg_dat[3] = Sys_ccsinf[18] & 0x07;
		MN_OUT_EVT(RT_MN_LCHEVT)->msg_dat[5] = MaxLCHCnt;
	break;
	case CALLMODE_IN:		//Incoming call
		MN_OUT_EVT(RT_MN_LCHEVT)->msg_dat[3] = Sys_ccsinf[18] & 0x07;
		MaxLCHCnt = 4;
		MN_OUT_EVT(RT_MN_LCHEVT)->msg_dat[5] = MaxLCHCnt;
	break;
	case CALLMODE_LOCREG:	//BCLTYLC :
		MN_OUT_EVT(RT_MN_LCHEVT)->msg_dat[1] |= 0x08;
		MN_OUT_EVT(RT_MN_LCHEVT)->msg_dat[2] = 0;
		MN_OUT_EVT(RT_MN_LCHEVT)->msg_dat[3] = 0x00;
		MN_OUT_EVT(RT_MN_LCHEVT)->msg_dat[5] = MaxLCHCnt;
	break;
	}

	MN_OUT_EVT(RT_MN_LCHEVT)->msg_dat[1] |= 0x02;
	if ( Sys_ccsinf[19] == 0x02 )
	{
		MN_OUT_EVT(RT_MN_LCHEVT)->msg_dat[2] += 0x01;
	}
	else if ( Sys_ccsinf[19] == 0x04 )
	{
		MN_OUT_EVT(RT_MN_LCHEVT)->msg_dat[2] += 0x02;
		MN_OUT_EVT(RT_MN_LCHEVT)->msg_dat[3] |= 0x08;

	}
}



void	Mn_IncomCallDsp(void)
{
	SYS_WORK->msg_adr = (M_MSB*)m_hntbuf();
	SYS_WORK->msg_adr->msg[0] = OPUBLIC;
	SYS_WORK->msg_adr->msg[1] = MINCCAL;
	SYS_WORK->msg_adr->msg[2] = 0x0A;
	SYS_WORK->msg_adr->msg[3] = IINCNO;		//Incoming call Number
	SYS_WORK->msg_adr->msg[4] = 8;
	SYS_WORK->msg_adr->msg[5] = 0x00;
	move_up_b((U1*)&SYS_WORK->msg_adr->msg[6] , Mn_Pch , 7);	//Can be replaced by Sys_cch ?
	exec_uap(SYS_WORK->msg_adr);

	IncFlg[phs_mode] = ON;
	CallChanel = phs_mode;
	CallMode = CALLMODE_IN;//BCLTYIN;
	Mn_SysCsInfSet();
	Sleep_Control(BSLPREL);
	#ifdef PROT_TEST
		HisOut(0x00,0xfe,0x06,0x00,0x00);
	#endif
	Mn_PCsyncCountStart();
}


void Mn_PSELRSSIChk(void)
{
	if(ST_PP_REPORT == Mn_state.public_mod)
		return;

	ClvlSum[phs_mode] = (BYTE)pc_rssi;

	if (pc_rssi < CCHh_CSlev)
	{
		if ( SLEEP_STS[phs_mode] != OFF )
		{
			if(CsyncCount[phs_mode] <= 1)
			{
				SYS_WORK->tsk_id = TASKMNG;
				MN_OUT_EVT(MN_TIMER_EVT)->tim_id = TICSYNC;
				MN_OUT_EVT(MN_TIMER_EVT)->tim_info[0] = phs_mode;
				m_excreq( (WORD*)&SYS_WORK->tsk_id );
				HisOut(0,0x0d6,0x05,0,0);
				A_count = 0;
			}
			else
				CsyncCount[phs_mode]--;
		}
	}
	else
	{
		CsyncCount[phs_mode] = Sys_csynctim[phs_mode];

		UwCrc_Err = 0;
	}
}


void Mn_UwCrcErrChk(void)
{

	ClvlSum[phs_mode] = (BYTE)pc_rssi;
	UwCrc_Err++;
	if ( Mn_PWaitCCHMonChk() == OK )
	{
		return;
	}
}


void Mn_Atimerstop(void)
{
	switch( Mn_InEvtCod[0] )
	{
	case TIWMONIT1 :
		WReMonTim = 0;
		WReMonTimN = 0;
	break;
	}
}



#ifdef __cplusplus
}
#endif

#endif