📄 adc_elmb.c
字号:
AdcOptoDelay = CS23_ELMB_SIGNAL_RISETIME;
}
/* Initialize ADC delta-change parameters from EEPROM */
if( adc_load_deltas() == FALSE ) result = FALSE;
/* Initialize ADC upper-limit parameters from EEPROM */
if( adc_load_upperlimits() == FALSE ) result = FALSE;
/* Initialize ADC lower-limit parameters from EEPROM */
if( adc_load_lowerlimits() == FALSE ) result = FALSE;
#ifdef __VARS_IN_EEPROM__
/* Create working copies of configuration globals in EEPROM */
if( eeprom_read( EE_ADCCHANS ) != AdcChans )
eeprom_write( EE_ADCCHANS, AdcChans );
if( eeprom_read( EE_ADCCONFIG ) != AdcConfig )
eeprom_write( EE_ADCCONFIG, AdcConfig );
if( eeprom_read( EE_ADCCALIBBEFORESCAN ) != AdcCalibBeforeScan )
eeprom_write( EE_ADCCALIBBEFORESCAN, AdcCalibBeforeScan );
if( eeprom_read( EE_ADCREADOUTONCHANGE ) != AdcReadoutOnChange )
eeprom_write( EE_ADCREADOUTONCHANGE, AdcReadoutOnChange );
if( eeprom_read( EE_ADCDELTASCANENABLED ) != AdcDeltaScanEnabled )
eeprom_write( EE_ADCDELTASCANENABLED, AdcDeltaScanEnabled );
if( eeprom_read( EE_ADCWINDOWSCANENABLED ) != AdcWindowScanEnabled )
eeprom_write( EE_ADCWINDOWSCANENABLED, AdcWindowScanEnabled );
if( eeprom_read( EE_ADCWINDOWCOUNTERINIT ) != AdcWindowCounterInit )
eeprom_write( EE_ADCWINDOWCOUNTERINIT, AdcWindowCounterInit );
if( eeprom_read( EE_ADCOPTODELAY ) != AdcOptoDelay )
eeprom_write( EE_ADCOPTODELAY, AdcOptoDelay );
#endif /* __VARS_IN_EEPROM__ */
return result;
}
/* ------------------------------------------------------------------------ */
#ifdef __ALL_MOTHERBOARDS__
/* ------------------------------------------------------------------------ */
void adc_set_sclk_v1( void )
{
ADC_SET_SCLK_V1();
}
/* ------------------------------------------------------------------------ */
void adc_clear_sclk_v1( void )
{
ADC_CLEAR_SCLK_V1();
}
/* ------------------------------------------------------------------------ */
void adc_set_sdi_v1( void )
{
ADC_SET_SDI_V1();
}
/* ------------------------------------------------------------------------ */
void adc_clear_sdi_v1( void )
{
ADC_CLEAR_SDI_V1();
}
/* ------------------------------------------------------------------------ */
BOOL adc_sdo_high_v1( void )
{
return( ADC_SDO_HIGH_V1() );
}
/* ------------------------------------------------------------------------ */
BOOL adc_sdo_low_v1( void )
{
return( ADC_SDO_LOW_V1() );
}
/* ------------------------------------------------------------------------ */
void adc_set_mux_latch_v1( void )
{
ADC_SET_MUX_LATCH_V1();
}
/* ------------------------------------------------------------------------ */
void adc_clear_mux_latch_v1( void )
{
ADC_CLEAR_MUX_LATCH_V1();
}
/* ------------------------------------------------------------------------ */
void adc_select_v1( void )
{
ADC_SELECT_V1();
}
/* ------------------------------------------------------------------------ */
void adc_deselect_v1( void )
{
ADC_DESELECT_V1();
}
/* ------------------------------------------------------------------------ */
void adc_set_sclk_v3( void )
{
ADC_SET_SCLK_V3();
}
/* ------------------------------------------------------------------------ */
void adc_clear_sclk_v3( void )
{
ADC_CLEAR_SCLK_V3();
}
/* ------------------------------------------------------------------------ */
void adc_set_sdi_v3( void )
{
ADC_SET_SDI_V3();
}
/* ------------------------------------------------------------------------ */
void adc_clear_sdi_v3( void )
{
ADC_CLEAR_SDI_V3();
}
/* ------------------------------------------------------------------------ */
BOOL adc_sdo_high_v3( void )
{
return( ADC_SDO_HIGH_V3() );
}
/* ------------------------------------------------------------------------ */
BOOL adc_sdo_low_v3( void )
{
return( ADC_SDO_LOW_V3() );
}
/* ------------------------------------------------------------------------ */
void adc_set_mux_latch_v3( void )
{
ADC_SET_MUX_LATCH_V3();
}
/* ------------------------------------------------------------------------ */
void adc_clear_mux_latch_v3( void )
{
ADC_CLEAR_MUX_LATCH_V3();
}
/* ------------------------------------------------------------------------ */
void adc_select_v3( void )
{
ADC_SELECT_V3();
}
/* ------------------------------------------------------------------------ */
void adc_deselect_v3( void )
{
ADC_DESELECT_V3();
}
/* ------------------------------------------------------------------------ */
static void motherboard_select( BYTE version )
{
/* Initialize the function pointers according to the selected Motherboard */
switch( version )
{
case 1:
ADC_SET_SCLK = adc_set_sclk_v1;
ADC_CLEAR_SCLK = adc_clear_sclk_v1;
ADC_SET_SDI = adc_set_sdi_v1;
ADC_CLEAR_SDI = adc_clear_sdi_v1;
ADC_SDO_HIGH = adc_sdo_high_v1;
ADC_SDO_LOW = adc_sdo_low_v1;
ADC_SET_MUX_LATCH = adc_set_mux_latch_v1;
ADC_CLEAR_MUX_LATCH = adc_clear_mux_latch_v1;
ADC_SELECT = adc_select_v1;
ADC_DESELECT = adc_deselect_v1;
break;
default:
ADC_SET_SCLK = adc_set_sclk_v3;
ADC_CLEAR_SCLK = adc_clear_sclk_v3;
ADC_SET_SDI = adc_set_sdi_v3;
ADC_CLEAR_SDI = adc_clear_sdi_v3;
ADC_SDO_HIGH = adc_sdo_high_v3;
ADC_SDO_LOW = adc_sdo_low_v3;
ADC_SET_MUX_LATCH = adc_set_mux_latch_v3;
ADC_CLEAR_MUX_LATCH = adc_clear_mux_latch_v3;
ADC_SELECT = adc_select_v3;
ADC_DESELECT = adc_deselect_v3;
break;
}
}
/* ------------------------------------------------------------------------ */
#endif /* __ALL_MOTHERBOARDS__ */
/* ------------------------------------------------------------------------ */
BOOL adc_set_calib_before_scan( BOOL calib )
{
if( calib > 1 ) return FALSE;
if( calib )
AdcCalibBeforeScan = TRUE;
else
AdcCalibBeforeScan = FALSE;
#ifdef __VARS_IN_EEPROM__
if( eeprom_read( EE_ADCCALIBBEFORESCAN ) != AdcCalibBeforeScan )
eeprom_write( EE_ADCCALIBBEFORESCAN, AdcCalibBeforeScan );
#endif /* __VARS_IN_EEPROM__ */
return TRUE;
}
/* ------------------------------------------------------------------------ */
BOOL adc_get_calib_before_scan( void )
{
#ifdef __VARS_IN_EEPROM__
AdcCalibBeforeScan = eeprom_read( EE_ADCCALIBBEFORESCAN );
#endif /* __VARS_IN_EEPROM__ */
return AdcCalibBeforeScan;
}
/* ------------------------------------------------------------------------ */
BOOL adc_set_readout_on_change( BOOL readout_on_change )
{
if( readout_on_change > 1 ) return FALSE;
if( readout_on_change )
{
/* If set from FALSE to TRUE, initialize delta reference ADC-counts
and readout-on-change counters */
if( AdcReadoutOnChange == FALSE )
adc_init_delta_references();
AdcReadoutOnChange = TRUE;
}
else
AdcReadoutOnChange = FALSE;
#ifdef __VARS_IN_EEPROM__
if( eeprom_read( EE_ADCREADOUTONCHANGE ) != AdcReadoutOnChange )
eeprom_write( EE_ADCREADOUTONCHANGE, AdcReadoutOnChange );
#endif /* __VARS_IN_EEPROM__ */
return TRUE;
}
/* ------------------------------------------------------------------------ */
BOOL adc_get_readout_on_change( void )
{
#ifdef __VARS_IN_EEPROM__
AdcReadoutOnChange = eeprom_read( EE_ADCREADOUTONCHANGE );
#endif /* __VARS_IN_EEPROM__ */
return AdcReadoutOnChange;
}
/* ------------------------------------------------------------------------ */
BOOL adc_set_delta_scan_ena( BOOL delta_scan_enable )
{
if( delta_scan_enable > 1 ) return FALSE;
if( delta_scan_enable )
{
/* Note: if set from FALSE to TRUE in the middle of readout-on-change
scanning the AdcRefCount[] is not properly initialised ! */
if( AdcDeltaScanEnabled == FALSE )
{
/* Init delta counters if delta-scan is set from FALSE to TRUE */
BYTE chan;
for( chan=0; chan<ADC_MAX_INPUTS; ++chan )
AdcDeltaCounter[chan] = 0;
/* Force setting of the analog input references
for the delta-change check */
AdcInitRefCount = TRUE;
}
AdcDeltaScanEnabled = TRUE;
}
else
AdcDeltaScanEnabled = FALSE;
#ifdef __VARS_IN_EEPROM__
if( eeprom_read( EE_ADCDELTASCANENABLED ) != AdcDeltaScanEnabled )
eeprom_write( EE_ADCDELTASCANENABLED, AdcDeltaScanEnabled );
#endif /* __VARS_IN_EEPROM__ */
return TRUE;
}
/* ------------------------------------------------------------------------ */
BOOL adc_get_delta_scan_ena( void )
{
#ifdef __VARS_IN_EEPROM__
AdcDeltaScanEnabled = eeprom_read( EE_ADCDELTASCANENABLED );
#endif /* __VARS_IN_EEPROM__ */
return AdcDeltaScanEnabled;
}
/* ------------------------------------------------------------------------ */
BOOL adc_set_window_scan_ena( BOOL window_scan_enable )
{
if( window_scan_enable > 1 ) return FALSE;
if( window_scan_enable )
{
/* Init window counters if window-scan is set from FALSE to TRUE */
if( AdcWindowScanEnabled == FALSE )
{
BYTE chan;
for( chan=0; chan<ADC_MAX_INPUTS; ++chan )
AdcWindowCounter[chan] = 0;
}
AdcWindowScanEnabled = TRUE;
}
else
AdcWindowScanEnabled = FALSE;
#ifdef __VARS_IN_EEPROM__
if( eeprom_read( EE_ADCWINDOWSCANENABLED ) != AdcWindowScanEnabled )
eeprom_write( EE_ADCWINDOWSCANENABLED, AdcWindowScanEnabled );
#endif /* __VARS_IN_EEPROM__ */
return TRUE;
}
/* ------------------------------------------------------------------------ */
BOOL adc_get_window_scan_ena( void )
{
#ifdef __VARS_IN_EEPROM__
AdcWindowScanEnabled = eeprom_read( EE_ADCWINDOWSCANENABLED );
#endif /* __VARS_IN_EEPROM__ */
return AdcWindowScanEnabled;
}
/* ------------------------------------------------------------------------ */
BOOL adc_set_window_scan_cntr( BYTE window_scan_counter )
{
if( window_scan_counter == 0 || window_scan_counter == 255 ) return FALSE;
AdcWindowCounterInit = window_scan_counter;
#ifdef __VARS_IN_EEPROM__
if( eeprom_read( EE_ADCWINDOWCOUNTERINIT ) != AdcWindowCounterInit )
eeprom_write( EE_ADCWINDOWCOUNTERINIT, AdcWindowCounterInit );
#endif /* __VARS_IN_EEPROM__ */
return TRUE;
}
/* ------------------------------------------------------------------------ */
BYTE adc_get_window_scan_cntr( void )
{
#ifdef __VARS_IN_EEPROM__
AdcWindowCounterInit = eeprom_read( EE_ADCWINDOWCOUNTERINIT );
#endif /* __VARS_IN_EEPROM__ */
return AdcWindowCounterInit;
}
/* ------------------------------------------------------------------------ */
static UINT16 adc_get_delta_cnt( BYTE chan_no )
{
/* Read one ADC delta-change parameter (3 bytes, unsigned)
from the working copy in EEPROM and convert it to a 16-bit ADC-count
depending on the current ADC configuration; this function is called
by the delta-change scanning function 'adc_delta_check()' */
BOOL unipolar;
BYTE adc_range_id;
float fullscale;
UINT16 ee_addr;
UINT16 delta_ui;
UINT32 delta_ul;
float delta_f;
BYTE *ptr;
/* Read the delta-change value from EEPROM into a longword */
ee_addr = EE_ADC_DELTA + chan_no*STORE_ADC_LIMIT_PARSIZE;
ptr = (BYTE *) &delta_ul;
*ptr = eepromw_read( ee_addr ); ++ptr; ++ee_addr;
*ptr = eepromw_read( ee_addr ); ++ptr; ++ee_addr;
*ptr = eepromw_read( ee_addr ); ++ptr;
*ptr = 0x00; /* This is an unsigned number */
/* or (less efficient, but portable):
delta_ul = (((UINT32) eepromw_read(ee_addr)) |
(((UINT32) eepromw_read(ee_addr+1)) << 8) |
(((UINT32) eepromw_read(ee_addr+2)) << 16));
*/
/* Get the ADC configuration */
unipolar = (AdcConfig & CS23_CSR_UNIPOLAR);
adc_range_id = ((AdcConfig & CS23_CSR_GAIN_MASK) >> CS23_CSR_GAIN_SHIFT);
fullscale = V_FULLSCALE[adc_range_id];
/* Convert it from microVolts to a 16-bit ADC-count */
delta_f = ((float) delta_ul) / fullscale;
if( unipolar )
{
delta_f *= 65535.0; /* Map to a 16-bit unsigned ADC-count */
/* Clip to maximum */
if( delta_f > 65535.0 )
delta_ui = (UINT16) 0xFFFF;
else
delta_ui = (UINT16) delta_f;
}
else
{
delta_f *= 32767.0; /* Map to a 16-bit signed ADC-count */
/* Clip to maximum */
if( delta_f > 32767.0 )
delta_ui = (UINT16) 0x7FFF;
else
delta_ui = (UINT16) delta_f;
}
/* If the stored delta is unequal to zero,
make sure that the delta-in-ADC-counts is at least 1
(a zero value is as if the channel is disabled for delta-change) */
if( delta_ui == 0 && delta_ul > 0L ) delta_ui = 1;
return delta_ui;
}
/* ------------------------------------------------------------------------ */
static UINT16 adc_get_upperlimit_cnt( BYTE chan_no )
{
/* Read one ADC upper-limit parameter (3 bytes, signed)
from the working copy in EEPROM and convert it to a 16-bit ADC-count
depending on the current ADC configuration; this function is called
by the upper/lower-limit scanning⌨️ 快捷键说明
复制代码
Ctrl + C
搜索代码
Ctrl + F
全屏模式
F11
切换主题
Ctrl + Shift + D
显示快捷键
?
增大字号
Ctrl + =
减小字号
Ctrl + -