?? hamaro_drv.c
字號:
/*******************************************************************************************************/
/* HAMARO_DRIVER_symbolrate_in() */
/*******************************************************************************************************/
long HAMARO_DRIVER_symbolrate_in( /* function to perform common symbol rate computation */
unsigned long symbolrate, /* symbol rate (in) */
unsigned long sampleratekhz) /* sample rate in hz (in) */
{
static HAMARO_BCDNO bcd;
unsigned long computed_symbolrate;
/* compute symbolrate programmed to the demod: (symbolrate * 2^23) / rounded(samplerate/1000) */
HAMARO_BCD_set(&bcd,(symbolrate*1000UL)+500UL);
HAMARO_BCD_mult(&bcd,(long)(0x01L<<23L));
HAMARO_BCD_div(&bcd,(sampleratekhz));
/* symbol rate */
computed_symbolrate = HAMARO_BCD_out(&bcd);
return((long)computed_symbolrate);
} /* HAMARO_DRIVER_symbolrate_in() */
/*******************************************************************************************************/
/* HAMARO_DRIVER_symbolrate_out() */
/*******************************************************************************************************/
long HAMARO_DRIVER_symbolrate_out( /* function to reverse symbolrate_in() function */
unsigned long symbolrate, /* symbol rate (in) */
unsigned long sampleratekhz) /* sample rate (in) */
{
static HAMARO_BCDNO bcd;
unsigned long computed_symbolrate = 0UL;
HAMARO_BCD_set(&bcd,(long)symbolrate);
HAMARO_BCD_mult(&bcd,100000L);
HAMARO_BCD_div(&bcd,(0x01L<<23L));
HAMARO_BCD_mult(&bcd,sampleratekhz);
HAMARO_BCD_div(&bcd,100000L);
computed_symbolrate = HAMARO_BCD_out(&bcd);
return((long)computed_symbolrate);
} /* HAMARO_DRIVER_symbolrate_out() */
/*******************************************************************************************************/
/* HAMARO_DRIVER_compute_demod_pll_mult() */
/*******************************************************************************************************/
unsigned long HAMARO_DRIVER_compute_demod_pll_mult( /* function to compute pll freq. */
HAMARO_NIM *nim, /* pointer to nim */
unsigned long Fs, /* sample frequency */
unsigned long Fc) /* crystal frequency */
{
unsigned long pll_mult;
unsigned short remainder;
if (Fs == 0UL || Fc == 0UL)
{
/* don't pass any div by zero possibilities */
if (nim != NULL)
{
HAMARO_DRIVER_SET_ERROR(nim,HAMARO_BAD_DIV);
}
return(0UL);
}
/* compute pll_mult = (Fs * 6L) / Fc */
/* make sure the result has the one extra digit from the fraction */
pll_mult = ((Fs * 6UL) + 5UL) / (Fc/10); /* CR 9760 */
remainder = (unsigned short)(pll_mult % 10);
pll_mult = pll_mult/10; /* loose the extra digit */
if (remainder > 5)
{
/* round the pll multiplier value */
pll_mult++;
}
return(pll_mult);
} /* HAMARO_DRIVER_compute_demod_pll_mult() */
/*******************************************************************************************************/
/* HAMARO_DRIVER_compute_fs() */
/*******************************************************************************************************/
unsigned long HAMARO_DRIVER_compute_fs( /* function to compute the sample frequency */
unsigned long pllmult, /* demod pll multiplier value */
unsigned long Fc) /* crystal frequency */
{
unsigned long rtn;
/* compute Fs = (Fc * pllmult) / 6 ; -> rounded -> (Fc * pllmult + 5) / 60 */
rtn = ((Fc * pllmult)+5UL)/6UL;
return(rtn);
} /* HAMARO_DRIVER_compute_fs() */
/*******************************************************************************************************/
/* HAMARO_DRIVER_SetPNSequence() */
/*******************************************************************************************************/
BOOL HAMARO_DRIVER_SetPNSequence( /* function to set the state of the PN machine */
HAMARO_NIM *nim, /* pointer to nim */
BOOL pnflag) /* True=on, False=off */
{
unsigned long ulRegVal;
BOOL rtn = True;
/* validate nim */
HAMARO_DRIVER_VALIDATE_NIM(nim);
switch(pnflag)
{
case True:
case False:
{
ulRegVal = (pnflag == True ? 0x01UL : 0x00UL);
if (HAMARO_RegisterWrite(nim,CX2430X_BERERRORSEL,ulRegVal, HAMARO_DEMOD_I2C_IO) == False) return(False);
break;
}
default:
{
HAMARO_DRIVER_SET_ERROR(nim,HAMARO_BAD_PARM);
rtn = False;
break;
}
} /* switch(... */
return(rtn);
} /* HAMARO_DRIVER_SetPNSequence() */
/*******************************************************************************************************/
/* HAMARO_DRIVER_GetPNSequence() */
/*******************************************************************************************************/
BOOL HAMARO_DRIVER_GetPNSequence( /* function to read current state of PN */
HAMARO_NIM *nim, /* pointer to nim */
BOOL *pnflag) /* True=enabled, False=disabled */
{
unsigned long ulRegVal;
/* validate nim */
HAMARO_DRIVER_VALIDATE_NIM(nim);
/* enable PN bER */
ulRegVal = 0x01;
if (HAMARO_RegisterWrite(nim,CX2430X_BERERRORSEL,ulRegVal, HAMARO_DEMOD_I2C_IO) == False) return(False);
if (pnflag == NULL)
{
HAMARO_DRIVER_SET_ERROR(nim,HAMARO_BAD_PARM);
return(False);
}
*pnflag = (ulRegVal == 0UL ? False : True);
return(True);
} /* HAMARO_DRIVER_GetPNSequence() */
/*******************************************************************************************************/
/* HAMARO_DRIVER_BBB_errinfo() */
/*******************************************************************************************************/
void HAMARO_DRIVER_BBB_errinfo( /* function for perform common error code for BERReadyCount[21:0], BYTE,Block */
HAMARO_NIM *nim, /* pointer to nim */
long *last_count, /* last error count (when changed, error count is ready) */
HAMARO_CMPLXNO *cpx, /* HAMARO_CMPLXNO holding result */
unsigned long errwindow, /* error window size */
unsigned long errmult, /* multiplier (different for BERReadyCount[21:0], BYTE, BLOCK and DVB */
HAMARO_MSTATUS *mstat) /* returned measurement status: (done, saturated, not-done) */
{
unsigned long ulRegVal;
long errcount;
/* sample is not yet ready */
HAMARO_DRIVER_set_complex(cpx,-1L,1UL);
*mstat = HAMARO_MSTATUS_NOTDONE;
/* read the window counter (this is the initial count) */
if (HAMARO_RegisterRead(nim,CX2430X_BERSTART,&ulRegVal, HAMARO_DEMOD_I2C_IO) == False) return;
/* test if a sample is ready */
if ((long)ulRegVal != *last_count)
{
/* save the current sample count */
*last_count = (long)ulRegVal;
/* freeze the counter */
ulRegVal = 0x00;
if (HAMARO_RegisterWrite(nim,CX2430X_BERSTART,ulRegVal, HAMARO_DEMOD_I2C_IO) == False) return;
/* test for errwindow valid range, warn user if out of valid range */
if (errwindow > 0xffUL)
{
HAMARO_DRIVER_SET_ERROR(nim,HAMARO_PARM_RANGE);
errwindow = 0xffUL;
}
/* read the err counter */
if (HAMARO_RegisterRead(nim,CX2430X_BERCOUNT_RS,&ulRegVal, HAMARO_DEMOD_I2C_IO) == False) return;
errcount = (long)ulRegVal;
HAMARO_DRIVER_set_complex(cpx,errcount,(errwindow*errmult));
*mstat = HAMARO_MSTATUS_DONE;
/* restart the counter */
ulRegVal = 0x01UL;
if (HAMARO_RegisterWrite(nim,CX2430X_BERSTART,ulRegVal, HAMARO_DEMOD_I2C_IO) == False) return;
}
return;
} /* HAMARO_DRIVER_BBB_errinfo() */
/*******************************************************************************************************/
/* HAMARO_DRIVER_error_measurements_off() */
/*******************************************************************************************************/
BOOL HAMARO_DRIVER_error_measurements_off( /* function to turn-OFF BER (i.e. BER, Byte, Block) settings */
HAMARO_NIM *nim) /* pointer to nim */
{
/* validate nim */
HAMARO_DRIVER_VALIDATE_NIM(nim);
/* turn either HAMARO_PNBER or BER (ber, Byte, block) */
if (HAMARO_DRIVER_BBB_error_off(nim) == False) return(False);
if (HAMARO_DRIVER_PNBER_error_off(nim) == False) return(False);
return(True);
} /* HAMARO_DRIVER_error_measurements_off() */
/*******************************************************************************************************/
/* HAMARO_DRIVER_BBB_error_off() */
/*******************************************************************************************************/
BOOL HAMARO_DRIVER_BBB_error_off( /* function to turn-OFF BER (i.e. BER, Byte, Block) settings */
HAMARO_NIM *nim) /* pointer to nim */
{
/* validate nim */
HAMARO_DRIVER_VALIDATE_NIM(nim);
/* if any BER measurement is on, turn it off */
if (nim->berbusy != -1L) return(HAMARO_GetBER(nim,0UL,NULL,NULL));
if (nim->bytebusy != -1L) return(HAMARO_GetByteErrors(nim,0UL,NULL,NULL));
if (nim->blockbusy != -1L) return(HAMARO_GetByteErrors(nim,0UL,NULL,NULL));
return(True);
} /* HAMARO_DRIVER_BBB_error_off() */
/*******************************************************************************************************/
/* HAMARO_DRIVER_errcount_disable() */
/*******************************************************************************************************/
BOOL HAMARO_DRIVER_errcount_disable( /* function to disable error count code */
HAMARO_NIM *nim) /* pointer to nim */
{
BOOL rtn = True;
/* validate nim */
HAMARO_DRIVER_VALIDATE_NIM(nim);
nim->berbusy = -1;
nim->bytebusy = -1;
nim->blockbusy = -1;
if (HAMARO_RegisterWrite(nim,CX2430X_BERRSSELECT,HAMARO_RSERRCNT_NONE, HAMARO_DEMOD_I2C_IO) != True) rtn = False;
if (HAMARO_RegisterWrite(nim,CX2430X_BERRSINFWINEN,0L, HAMARO_DEMOD_I2C_IO) != True) rtn = False;
return(rtn);
} /* HAMARO_DRIVER_errcount_disable() */
/*******************************************************************************************************/
/* HAMARO_DRIVER_PNBER_error_off() */
/*******************************************************************************************************/
BOOL HAMARO_DRIVER_PNBER_error_off( /* function to turn-OFF PN BER settings */
HAMARO_NIM *nim) /* pointer to nim */
{
/* validate nim */
HAMARO_DRIVER_VALIDATE_NIM(nim);
/* if PN BER measurement is on, turn it off */
if (nim->pnberbusy != -1L) return(HAMARO_GetPNBER(nim,HAMARO_PNBER_UNDEF,(HAMARO_CMPLXNO*)NULL,(HAMARO_MSTATUS*)NULL));
return(True);
} /* HAMARO_DRIVER_PNBER_error_off() */
/*******************************************************************************************************/
/* HAMARO_DRIVER_Reset() */
/*******************************************************************************************************/
BOOL HAMARO_DRIVER_Reset( /* function to perform a demod reset operation */
HAMARO_NIM *nim) /* pointer to nim */
{
unsigned long ulRegVal;
BOOL rtn = True;
/* validate nim */
HAMARO_DRIVER_VALIDATE_NIM(nim);
/* set demod registers to the default state */
if (HAMARO_DRIVER_Default(nim) == False) rtn = False;
/* reset the demod */
ulRegVal = 0x01UL;
if (HAMARO_RegisterWrite(nim,CX2430X_RSTHAMARO,ulRegVal, HAMARO_DEMOD_I2C_IO) == False) rtn = False;
ulRegVal = 0x00UL;
if (HAMARO_RegisterWrite(nim,CX2430X_RSTHAMARO,ulRegVal, HAMARO_DEMOD_I2C_IO) == False) rtn = False;
return(rtn);
} /* HAMARO_DRIVER_Reset() */
/*******************************************************************************************************/
/* HAMARO_DRIVER_Preset() */
/*******************************************************************************************************/
BOOL HAMARO_DRIVER_Preset( /* function to perform a demod preset operation */
HAMARO_NIM *nim) /* pointer to nim */
{
unsigned long ulRegVal;
BOOL rtn = True;
/* validate nim */
HAMARO_DRIVER_VALIDATE_NIM(nim);
/* preset the demod */
ulRegVal = 0x02UL;
if (HAMARO_RegisterWrite(nim,CX2430X_RSTHAMARO,ulRegVal, HAMARO_DEMOD_I2C_IO) == False) rtn = False;
?? 快捷鍵說明
復制代碼
Ctrl + C
搜索代碼
Ctrl + F
全屏模式
F11
切換主題
Ctrl + Shift + D
顯示快捷鍵
?
增大字號
Ctrl + =
減小字號
Ctrl + -