📄 demod_dcf.c
字号:
{
if( u16RegAddr == 0x?? )
BusAccessMethod = I2C_BUS_ACCESS;
else
BusAccessMethod = ASX_BUS_ACCESS;
}
else
BusAccessMethod = ASX_BUS_ACCESS; */
BusAccessMethod = I2C_BUS_ACCESS;
switch(BusAccessMethod)
{
case I2C_BUS_ACCESS:
{
/* slave device address */
u8IICSlaveAddr = (unsigned char)(u32Handle & 0xFF);
if(u8IICSlaveAddr == DCF_DEMOD_I2C_ADDR)
{
/* additional phase
slave address --- IIC_START
base address/index --- IIC_DATA
--- IIC_STOP */
u8Data[0] = u8IICSlaveAddr; /* i2c slave address - WR */
u8Data[1] = (unsigned char)u16RegAddr & 0xFF; /* base register address */
u8Cmd[0] = IIC_START;
u8Cmd[1] = IIC_DATA;
u8Cmd[2] = IIC_STOP;
iicTransBuf.dwCount = 3;
iicTransBuf.pData = u8Data;
iicTransBuf.pCmd = u8Cmd;
if(iicTransaction(&iicTransBuf, (unsigned char)I2C_BUS_DCF) != TRUE)
{
/* error code = iicTransBuf.dwError */
return(False);
}
}
/* slave address/read --- IIC_START
base address + 0 data --- IIC_DATA
base address + 1 data --- IIC_DATA
base address + n data --- IIC_DATA
--- IIC_STOP */
/* cmd sent to slave device */
u8Data[0] = u8IICSlaveAddr | 0x01; /* i2c slave address - RD */
for(i = 0; i < u8RegCount; i++)
{
u8Data[i+1] = 0;
}
/* cmd type */
u8Cmd[0] = IIC_START;
for(i = 0; i < u8RegCount; i++)
{
u8Cmd[i+1] = IIC_DATA;
}
u8Cmd[u8RegCount+1] = IIC_STOP;
iicTransBuf.dwCount = u8RegCount + 2;
iicTransBuf.pData = u8Data;
iicTransBuf.pCmd = u8Cmd;
/* send out CMD */
if(iicTransaction(&iicTransBuf, I2C_BUS_DCF) != TRUE)
return(False);
/* save registers content to buffer */
for(i = 0; i < u8RegCount; i++)
*(pu8Data+i) = u8Data[i+1];
break;
}
case ASX_BUS_ACCESS:
break;
default:
debug_out(TL_ERROR, "DCF does not support this type of access method.\n");
break;
}
return(True);
}
/*****************************************************************************/
/* FUNCTION: xlat_modetype_in */
/* */
/* PARAMETERS: cablemod - the MODULATION as defined for multi-instance */
/* demod. */
/* */
/* DESCRIPTION: This function translates an MODULATION from the enumeration */
/* used by multi-instance demod to that used DCF driver code */
/* */
/* RETURNS: The DCF driver code equivalent MODULATION rate. */
/* */
/* CONTEXT: May be called from interrupt or non-interrupt context. */
/* */
/*****************************************************************************/
static DCF_MOD_TYPE xlat_modetype_in(NIM_CABLE_MODULATION cablemod)
{
switch(cablemod)
{
case MOD_QAMAUTO:
return(DCF_MOD_QAMAUTO);
case MOD_QAM16:
return(DCF_MOD_QAM16);
case MOD_QAM32:
return(DCF_MOD_QAM32);
case MOD_QAM64:
return(DCF_MOD_QAM64);
case MOD_QAM128:
return(DCF_MOD_QAM128);
case MOD_QAM256:
return(DCF_MOD_QAM256);
default:
return(DCF_MOD_QAM_UNDEF);
}
}
/*****************************************************************************/
/* FUNCTION: xlat_specinv_in */
/* */
/* PARAMETERS: spevinv - the SPECTRUM INVERSION as defined for */
/* multi-instance demod. */
/* */
/* DESCRIPTION: This function translates an SPECTRUM INVERSION from the */
/* enumeration used by multi-instance demod to that used DCF */
/* driver code */
/* */
/* RETURNS: The DCF driver code equivalent SPECTRUM INVERSION */
/* */
/* CONTEXT: May be called from interrupt or non-interrupt context. */
/* */
/*****************************************************************************/
static DCF_SPECINV xlat_specinv_in(NIM_CABLE_SPECTRUM spevinv)
{
switch(spevinv)
{
case SPECTRUM_NORMAL:
return(DCF_SPEC_INV_OFF);
case SPECTRUM_INVERTED:
return(DCF_SPEC_INV_ON);
default:
return(DCF_SPEC_INV_UNDEF);
}
}
/*****************************************************************************/
/* FUNCTION: xlat_annex_in */
/* */
/* PARAMETERS: annex - the annex defined in the cable standard. */
/* */
/* DESCRIPTION: This function translates an SPECTRUM INVERSION from the */
/* enumeration used by multi-instance demod to that used DCF */
/* driver code */
/* */
/* RETURNS: The DCF driver code equivalent SPECTRUM INVERSION */
/* */
/* CONTEXT: May be called from interrupt or non-interrupt context. */
/* */
/*****************************************************************************/
static DCF_ANNEX xlat_annex_in(NIM_CABLE_ANNEX annex)
{
switch(annex)
{
case ANNEX_A:
return(DCF_ANNEX_A);
case ANNEX_B:
return(DCF_ANNEX_B);
default:
return(DCF_ANNEX_UNDEF);
}
}
/*****************************************************************************/
/* FUNCTION: cnxt_dcf_acquire */
/* */
/* PARAMETERS: u32Unit - the unit specified in the DISCONNECT message. */
/* pTuning - the struct stuffed tunning parameters. */
/* */
/* DESCRIPTION: This function implements the acquisition of signal. */
/* */
/* RETURNS: DEMOD_UNINITIALIZED - this module has not been initialized. */
/* DEMOD_BAD_UNIT - the unit number is not valid. */
/* DEMOD_BAD_PARAMETER - there is a bad parameter. */
/* DEMOD_SUCCESS - the function completed successfully. */
/* */
/* CONTEXT: Will be run in task context. */
/* */
/*****************************************************************************/
static DEMOD_STATUS cnxt_dcf_acquire(u_int32 u32Unit)
{
DCF_CHANOBJ chanobj;
DEMOD_CALLBACK_DATA CallbackData;
bool bRetVal;
int i, j;
/*debug_out(TL_ALWAYS, "DCF begins to acquire the signal!\n");*/
/* initialize quality */
NIMs[u32Unit].signal_strength = 0;
NIMs[u32Unit].cne = 0;
/* change the status to acquiring */
if(NIMs[u32Unit].cur_state != DCF_NIM_ACQUIRING)
NIMs[u32Unit].cur_state = DCF_NIM_ACQUIRING;
/* get parameters of TS */
chanobj.frequency = gLocalTuning[u32Unit].tune.nim_cable_tune.frequency;
chanobj.symbrate = gLocalTuning[u32Unit].tune.nim_cable_tune.symbol_rate;
chanobj.modulation = xlat_modetype_in(gLocalTuning[u32Unit].tune.nim_cable_tune.modulation);
chanobj.spectrum = xlat_specinv_in(gLocalTuning[u32Unit].tune.nim_cable_tune.spectrum);
chanobj.auto_spectrum = gLocalTuning[u32Unit].tune.nim_cable_tune.auto_spectrum;
chanobj.annex = xlat_annex_in(gLocalTuning[u32Unit].tune.nim_cable_tune.annex);
/* debug_out(TL_ALWAYS, "cnxt_dcf_acquire: FREQ=%d SR=%d MOD=%d\n", chanobj.frequency, chanobj.symbrate, chanobj.modulation); */
/* connet to acquire signal */
bRetVal = dcf_change_channel(&NIMs[u32Unit], &chanobj);
j = 1;
trace("DCF UNIT %d connect %d\n", u32Unit, j);
for(i = 0; i < DCF_RETRY_NUMBER; i++)
{
/* exit the current acquiring right now before any new acquiring!!! */
if(NIMs[u32Unit].exit_acquring == True)
{
NIMs[u32Unit].cur_state = DCF_NIM_NEWACQUIRING;
NIMs[u32Unit].pre_state = NIMs[u32Unit].cur_state;
return(DEMOD_SUCCESS);
}
bRetVal = dcf_change_channel(&NIMs[u32Unit], &chanobj);
trace("DCF UNIT %d connect %d\n", u32Unit, 2+i);
if(bRetVal == True)
{
debug_out(TL_ALWAYS, "DCF UNIT %d CONNECTED\n", u32Unit);
NIMs[u32Unit].cur_state = DCF_NIM_LOCKED;
NIMs[u32Unit].pre_state = NIMs[u32Unit].cur_state;
/* give feed back to middle level */
if(gpfnCallbacks[u32Unit])
{
CallbackData.parm.type = DEMOD_CONNECTED;
gpfnCallbacks[u32Unit](gu32LocalModule, u32Unit, DEMOD_CONNECT_STATUS, &CallbackData);
}
break;
}
else
{
if(chanobj.auto_spectrum == 1)
{
if(chanobj.spectrum == DCF_SPEC_INV_OFF)
{
debug_out(TL_INFO, "cnxt_dcf_acquire DCF_SPEC_INV_OFF\n");
chanobj.spectrum = DCF_SPEC_INV_ON;
}
else if(chanobj.spectrum == DCF_SPEC_INV_ON)
{
debug_out(TL_INFO, "cnxt_dcf_acquire DCF_SPEC_INV_ON\n");
chanobj.spectrum = DCF_SPEC_INV_OFF;
}
}
}
}
/* DCF can not acquire the signal */
if(bRetVal == False)
{
debug_out(TL_INFO, "DCF UNIT %d FAILED\n", u32Unit);
NIMs[u32Unit].cur_state = DCF_NIM_FAILED;
NIMs[u32Unit].pre_state = NIMs[u32Unit].cur_state;
/* give feed back to the middle level */
if(gpfnCallbacks[u32Unit])
{
CallbackData.parm.type = DEMOD_FAILED;
gpfnCallbacks[u32Unit](gu32LocalModule, u32Unit, DEMOD_CONNECT_STATUS, &CallbackData);
}
}
⌨️ 快捷键说明
复制代码
Ctrl + C
搜索代码
Ctrl + F
全屏模式
F11
切换主题
Ctrl + Shift + D
显示快捷键
?
增大字号
Ctrl + =
减小字号
Ctrl + -