mirror of
https://github.com/slsdetectorgroup/slsDetectorPackage.git
synced 2025-06-23 18:17:59 +02:00
in between
This commit is contained in:
@ -1,8 +1,6 @@
|
||||
#pragma once
|
||||
|
||||
//#include "commonServerFunctions.h" // blackfin.h, ansi.h
|
||||
|
||||
|
||||
#include "commonServerFunctions.h" // blackfin.h, ansi.h
|
||||
|
||||
/* AD7689 ADC DEFINES */
|
||||
|
||||
@ -60,22 +58,161 @@
|
||||
#define AD7689_CFG_CFG_NO_UPDATE_VAL ((0x0 << AD7689_CFG_CFG_OFST) & AD7689_CFG_CFG_MSK)
|
||||
#define AD7689_CFG_CFG_OVRWRTE_VAL ((0x1 << AD7689_CFG_CFG_OFST) & AD7689_CFG_CFG_MSK)
|
||||
|
||||
int getAD7689(int ind) {
|
||||
#define AD7689_ADC_CFG_NUMBITS (14)
|
||||
#define AD7689_ADC_DATA_NUMBITS (16)
|
||||
#define AD7689_NUM_CHANNELS (7)
|
||||
#define AD7689_NUM_INVALID_CONVERSIONS (3)
|
||||
#define AD7689_INT_REF_MAX_MV (2500) // chosen using reference buffer selection in config reg
|
||||
#define AD7689_INT_REF_MIN_MV (0)
|
||||
#define AD7689_TMP_C_FOR_1_MV (25.00 / 283)
|
||||
|
||||
|
||||
uint32_t AD7689_Reg = 0x0;
|
||||
uint32_t AD7689_ROReg = 0x0;
|
||||
uint32_t AD7689_CnvMask = 0x0;
|
||||
uint32_t AD7689_ClkMask = 0x0;
|
||||
uint32_t AD7689_DigMask = 0x0;
|
||||
int AD7689_DigOffset = 0x0;
|
||||
|
||||
/**
|
||||
* Set Defines
|
||||
* @param reg spi register
|
||||
* @param roreg spi readout register
|
||||
* @param cmsk conversion mask
|
||||
* @param clkmsk clock output mask
|
||||
* @param dmsk digital output mask
|
||||
* @param dofst digital output offset
|
||||
*/
|
||||
void AD7689_SetDefines(uint32_t reg, uint32_t roreg, uint32_t cmsk, uint32_t clkmsk, uint32_t dmsk, int dofst) {
|
||||
AD7689_Reg = reg;
|
||||
AD7689_ROReg = roreg;
|
||||
AD7689_CnvMask = cmsk;
|
||||
AD7689_ClkMask = clkmsk;
|
||||
AD7689_DigMask = dmsk;
|
||||
AD7689_DigOffset = dofst;
|
||||
}
|
||||
|
||||
/**
|
||||
* Disable SPI
|
||||
*/
|
||||
void AD7689_Disable() {
|
||||
bus_w(AD7689_Reg, bus_r(AD7689_Reg)
|
||||
| AD7689_CnvMask
|
||||
| AD7689_ClkMask
|
||||
&~(AD7689_DigMask));
|
||||
}
|
||||
|
||||
/**
|
||||
* Set SPI reg value
|
||||
* @param codata value to be set
|
||||
*/
|
||||
void AD7689_Set(u_int32_t codata) {
|
||||
FILE_LOG(logINFO, ("\tSetting ADC SPI Register. Writing 0x%08x to Config Reg\n", codata));
|
||||
serializeToSPI(AD7689_Reg, codata, AD7689_CnvMask, AD7689_ADC_CFG_NUMBITS,
|
||||
AD7689_ClkMask, AD7689_DigMask, AD7689_DigOffset);
|
||||
}
|
||||
|
||||
/**
|
||||
* Get SPI reg value
|
||||
* @returns SPI reg value
|
||||
*/
|
||||
uint16_t AD7689_Get() {
|
||||
FILE_LOG(logINFO, ("\tGetting ADC SPI Register.\n"));
|
||||
return (uint16_t)serializeFromSPI(AD7689_ROReg, AD7689_Reg, AD7689_CnvMask, AD7689_ADC_DATA_NUMBITS,
|
||||
AD7689_ClkMask, AD7689_DigMask);
|
||||
}
|
||||
|
||||
/**
|
||||
* Get temperature
|
||||
* @returns temperature in °C
|
||||
*/
|
||||
int AD7689_GetTemperature() {
|
||||
AD7689_Set(
|
||||
// read back
|
||||
AD7689_CFG_RB_MSK |
|
||||
// disable sequencer (different from config)
|
||||
AD7689_CFG_SEQ_DSBLE_VAL |
|
||||
// Internal reference. REF = 2.5V buffered output. Temperature sensor enabled.
|
||||
AD7689_CFG_REF_INT_2500MV_VAL |
|
||||
// full bandwidth of low pass filter
|
||||
AD7689_CFG_BW_FULL_VAL |
|
||||
// all channel (different from config)
|
||||
AD7689_CFG_IN_MSK |
|
||||
// temperature sensor (different from config)
|
||||
AD7689_CFG_INCC_TMP_VAL |
|
||||
// overwrite configuration
|
||||
AD7689_CFG_CFG_OVRWRTE_VAL);
|
||||
|
||||
// FIXME: do we have to read it 8 times?? (sequencer is disabled anyway) or are we sequencing, then we read only last channel
|
||||
uint16_t regval = AD7689_Get();
|
||||
|
||||
// value in mV FIXME: page 17? reference voltage temperature coefficient or t do with -40 to 85 °C
|
||||
uint16_t vmin = AD7689_INT_REF_MIN_MV;
|
||||
uint16_t vmax = AD7689_INT_REF_MAX_MV;
|
||||
uint16_t nsteps = (2 ^ AD7689_ADC_DATA_NUMBITS);
|
||||
uint16_t retval = (vmin + (vmax - vmin) * regval / (nsteps - 1));
|
||||
FILE_LOG(logDEBUG1, ("\tvoltage read for temp: 0x%d mV\n", retval));
|
||||
|
||||
// value in °C
|
||||
uint16_t temp = AD7689_TMP_C_FOR_1_MV * retval;
|
||||
FILE_LOG(logDEBUG1, ("\ttemp read: 0x%d °C\n", temp));
|
||||
|
||||
return temp;
|
||||
|
||||
}
|
||||
|
||||
void setAD7689(int addr, int val) {
|
||||
u_int32_t codata;
|
||||
codata = val + (addr << 8);
|
||||
FILE_LOG(logINFO, ("\tSetting ADC SPI Register. Wrote 0x%04x at 0x%04x\n", val, addr));
|
||||
serializeToSPI(ADC_SPI_REG, codata, ADC_SERIAL_CS_OUT_MSK, AD9257_ADC_NUMBITS,
|
||||
ADC_SERIAL_CLK_OUT_MSK, ADC_SERIAL_DATA_OUT_MSK, ADC_SERIAL_DATA_OUT_OFST);
|
||||
/**
|
||||
* Reads channels voltage
|
||||
* @param ichan channel number from 0 to 7
|
||||
* @returns channel voltage in mV
|
||||
*/
|
||||
int AD7689_GetChannel(int ichan) {
|
||||
// filter channels val
|
||||
if (ichan < 0 || ichan >= AD7689_NUM_CHANNELS) {
|
||||
FILE_LOG(logERROR, ("Cannot get slow adc channel. "
|
||||
"%d out of bounds (0 to %d)\n", ichan, AD7689_NUM_CHANNELS - 1));
|
||||
return -1;
|
||||
}
|
||||
|
||||
AD7689_Set(
|
||||
// read back
|
||||
AD7689_CFG_RB_MSK |
|
||||
// disable sequencer (different from config)
|
||||
AD7689_CFG_SEQ_DSBLE_VAL |
|
||||
// Internal reference. REF = 2.5V buffered output. Temperature sensor enabled.
|
||||
AD7689_CFG_REF_INT_2500MV_VAL |
|
||||
// full bandwidth of low pass filter
|
||||
AD7689_CFG_BW_FULL_VAL |
|
||||
// specific channel (different from config)
|
||||
((ichan << AD7689_CFG_IN_OFST) & AD7689_CFG_IN_MSK) |
|
||||
// input channel configuration (unipolar. inx to gnd)
|
||||
AD7689_CFG_INCC_UNPLR_IN_GND_VAL |
|
||||
// overwrite configuration
|
||||
AD7689_CFG_CFG_OVRWRTE_VAL);
|
||||
|
||||
// FIXME: do we have to read it 8 times?? (sequencer is disabled anyway) or are we sequencing, then we read only last channel
|
||||
uint16_t regval = AD7689_Get();
|
||||
|
||||
// value in mV
|
||||
uint16_t vmin = AD7689_INT_REF_MIN_MV;
|
||||
uint16_t vmax = AD7689_INT_REF_MAX_MV;
|
||||
uint16_t nsteps = (2 ^ AD7689_ADC_DATA_NUMBITS);
|
||||
uint16_t retval = (vmin + (vmax - vmin) * regval / (nsteps - 1));
|
||||
FILE_LOG(logINFO, ("\tvoltage read for chan %d: 0x%d mV\n", retval));
|
||||
|
||||
return retval;
|
||||
}
|
||||
|
||||
void prepareAD7689(){
|
||||
FILE_LOG(logINFOBLUE, ("Preparing AD7689 (Slow ADCs):\n"));
|
||||
/**
|
||||
* Configure
|
||||
*/
|
||||
void AD7689_Configure(){
|
||||
FILE_LOG(logINFOBLUE, ("Configuring AD7689 (Slow ADCs):\n"));
|
||||
|
||||
uint16_t codata = (
|
||||
// from power up, 3 invalid conversions
|
||||
int i = 0;
|
||||
for (i = 0; i < AD7689_NUM_INVALID_CONVERSIONS; ++i) {
|
||||
AD7689_Set(
|
||||
// read back
|
||||
AD7689_CFG_RB_MSK |
|
||||
// scan sequence IN0-IN7 then temperature sensor
|
||||
@ -90,5 +227,5 @@ void prepareAD7689(){
|
||||
AD7689_CFG_INCC_UNPLR_IN_GND_VAL |
|
||||
// overwrite configuration
|
||||
AD7689_CFG_CFG_OVRWRTE_VAL);
|
||||
|
||||
}
|
||||
}
|
||||
|
||||
@ -100,63 +100,101 @@
|
||||
#define AD9252_OUT_CLK_600_VAL ((0xa << AD9252_OUT_CLK_OFST) & AD9252_OUT_CLK_MSK)
|
||||
#define AD9252_OUT_CLK_660_VAL ((0xb << AD9252_OUT_CLK_OFST) & AD9252_OUT_CLK_MSK) // 0xb - 0xf is 660
|
||||
|
||||
uint32_t AD9252_Reg = 0x0;
|
||||
uint32_t AD9252_CsMask = 0x0;
|
||||
uint32_t AD9252_ClkMask = 0x0;
|
||||
uint32_t AD9252_DigMask = 0x0;
|
||||
int AD9252_DigOffset = 0x0;
|
||||
|
||||
|
||||
void setAdc9252(int addr, int val) {
|
||||
|
||||
u_int32_t codata;
|
||||
codata = val + (addr << 8);
|
||||
FILE_LOG(logINFO, ("\tSetting ADC SPI Register. Wrote 0x%04x at 0x%04x\n", val, addr));
|
||||
serializeToSPI(ADC_SPI_REG, codata, ADC_SERIAL_CS_OUT_MSK, AD9252_ADC_NUMBITS,
|
||||
ADC_SERIAL_CLK_OUT_MSK, ADC_SERIAL_DATA_OUT_MSK, ADC_SERIAL_DATA_OUT_OFST);
|
||||
/**
|
||||
* Set Defines
|
||||
* @param reg spi register
|
||||
* @param cmsk chip select mask
|
||||
* @param clkmsk clock output mask
|
||||
* @param dmsk digital output mask
|
||||
* @param dofst digital output offset
|
||||
*/
|
||||
void AD9252_SetDefines(uint32_t reg, uint32_t cmsk, uint32_t clkmsk, uint32_t dmsk, int dofst) {
|
||||
AD9252_Reg = reg;
|
||||
AD9252_CsMask = cmsk;
|
||||
AD9252_ClkMask = clkmsk;
|
||||
AD9252_DigMask = dmsk;
|
||||
AD9252_DigOffset = dofst;
|
||||
}
|
||||
|
||||
void prepareADC9252(){
|
||||
FILE_LOG(logINFOBLUE, ("Preparing ADC9252:\n"));
|
||||
/**
|
||||
* Disable SPI
|
||||
*/
|
||||
void AD9252_Disable() {
|
||||
bus_w(AD9252_REG, bus_r(AD9252_REG)
|
||||
| AD9252_CS_MSK
|
||||
| AD9252_CLK_MSK
|
||||
&~(AD9252_DT_MSK));
|
||||
}
|
||||
|
||||
//power mode reset
|
||||
/**
|
||||
* Set SPI reg value
|
||||
* @param codata value to be set
|
||||
*/
|
||||
void AD9252_Set(int addr, int val) {
|
||||
|
||||
u_int32_t codata;
|
||||
codata = val + (addr << 8);
|
||||
FILE_LOG(logINFO, ("\tSetting ADC SPI Register. Wrote 0x%04x at 0x%04x\n", val, addr));
|
||||
serializeToSPI(AD9252_REG, codata, AD9252_CS_MSK, AD9252_ADC_NUMBITS,
|
||||
AD9252_CLK_MSK, AD9252_DT_MSK, AD9252_DT_OFST);
|
||||
}
|
||||
|
||||
/**
|
||||
* Configure
|
||||
*/
|
||||
void AD9252_Configure(){
|
||||
FILE_LOG(logINFOBLUE, ("Configuring ADC9252:\n"));
|
||||
|
||||
//power mode reset
|
||||
FILE_LOG(logINFO, ("\tPower mode reset\n"));
|
||||
setAdc9252(AD9252_POWER_MODE_REG, AD9252_INT_RESET_VAL);
|
||||
AD9252_Set(AD9252_POWER_MODE_REG, AD9252_INT_RESET_VAL);
|
||||
/*#ifdef GOTTHARDD //FIXME:?
|
||||
usleep(50000);
|
||||
usleep(50000);
|
||||
#endif*/
|
||||
|
||||
//power mode chip run
|
||||
FILE_LOG(logINFO, ("\tPower mode chip run\n"));
|
||||
setAdc9252(AD9252_POWER_MODE_REG, AD9252_INT_CHIP_RUN_VAL);
|
||||
//power mode chip run
|
||||
FILE_LOG(logINFO, ("\tPower mode chip run\n"));
|
||||
AD9252_Set(AD9252_POWER_MODE_REG, AD9252_INT_CHIP_RUN_VAL);
|
||||
#ifdef GOTTHARDD
|
||||
/*usleep(50000);*///FIXME:?
|
||||
/*usleep(50000);*///FIXME:?
|
||||
|
||||
// binary offset
|
||||
// binary offset
|
||||
FILE_LOG(logINFO, ("\tBinary offset\n"));
|
||||
setAdc9252(AD9252_OUT_MODE_REG, AD9252_OUT_BINARY_OFST_VAL);
|
||||
AD9252_Set(AD9252_OUT_MODE_REG, AD9252_OUT_BINARY_OFST_VAL);
|
||||
/*usleep(50000);*///FIXME:?
|
||||
#endif
|
||||
|
||||
//output clock phase
|
||||
FILE_LOG(logINFO, ("\tOutput clock phase\n"));
|
||||
setAdc9252(AD9252_OUT_PHASE_REG, AD9252_OUT_CLK_60_VAL);
|
||||
//output clock phase
|
||||
FILE_LOG(logINFO, ("\tOutput clock phase\n"));
|
||||
AD9252_Set(AD9252_OUT_PHASE_REG, AD9252_OUT_CLK_60_VAL);
|
||||
|
||||
// lvds-iee reduced , binary offset
|
||||
FILE_LOG(logINFO, ("\tLvds-iee reduced, binary offset\n"));
|
||||
setAdc9252(AD9252_OUT_MODE_REG, AD9252_OUT_LVDS_IEEE_VAL);
|
||||
// lvds-iee reduced , binary offset
|
||||
FILE_LOG(logINFO, ("\tLvds-iee reduced, binary offset\n"));
|
||||
AD9252_Set(AD9252_OUT_MODE_REG, AD9252_OUT_LVDS_IEEE_VAL);
|
||||
|
||||
// all devices on chip to receive next command
|
||||
FILE_LOG(logINFO, ("\tAll devices on chip to receive next command\n"));
|
||||
setAdc9252(AD9252_DEV_IND_2_REG,
|
||||
AD9252_CHAN_H_MSK | AD9252_CHAN_G_MSK | AD9252_CHAN_F_MSK | AD9252_CHAN_E_MSK);
|
||||
setAdc9252(AD9252_DEV_IND_1_REG,
|
||||
AD9252_CHAN_D_MSK | AD9252_CHAN_C_MSK | AD9252_CHAN_B_MSK | AD9252_CHAN_A_MSK |
|
||||
AD9252_CLK_CH_DCO_MSK | AD9252_CLK_CH_IFCO_MSK); // unlike 9257, by default ad9252 has this (dco and ifco)off
|
||||
// all devices on chip to receive next command
|
||||
FILE_LOG(logINFO, ("\tAll devices on chip to receive next command\n"));
|
||||
AD9252_Set(AD9252_DEV_IND_2_REG,
|
||||
AD9252_CHAN_H_MSK | AD9252_CHAN_G_MSK | AD9252_CHAN_F_MSK | AD9252_CHAN_E_MSK);
|
||||
AD9252_Set(AD9252_DEV_IND_1_REG,
|
||||
AD9252_CHAN_D_MSK | AD9252_CHAN_C_MSK | AD9252_CHAN_B_MSK | AD9252_CHAN_A_MSK |
|
||||
AD9252_CLK_CH_DCO_MSK | AD9252_CLK_CH_IFCO_MSK); // unlike 9257, by default ad9252 has this (dco and ifco)off
|
||||
|
||||
// no test mode
|
||||
FILE_LOG(logINFO, ("\tNo test mode\n"));
|
||||
setAdc9252(AD9252_TEST_MODE_REG, AD9252_TST_OFF_VAL);
|
||||
// no test mode
|
||||
FILE_LOG(logINFO, ("\tNo test mode\n"));
|
||||
AD9252_Set(AD9252_TEST_MODE_REG, AD9252_TST_OFF_VAL);
|
||||
|
||||
#ifdef TESTADC
|
||||
FILE_LOG(logINFOBLUE, ("Putting ADC in Test Mode!\n");
|
||||
// mixed bit frequency test mode
|
||||
FILE_LOG(logINFO, ("\tMixed bit frequency test mode\n"));
|
||||
setAdc9252(AD9252_TEST_MODE_REG, AD9252_TST_MXD_BT_FRQ_VAL);
|
||||
FILE_LOG(logINFOBLUE, ("Putting ADC in Test Mode!\n");
|
||||
// mixed bit frequency test mode
|
||||
FILE_LOG(logINFO, ("\tMixed bit frequency test mode\n"));
|
||||
AD9252_Set(AD9252_TEST_MODE_REG, AD9252_TST_MXD_BT_FRQ_VAL);
|
||||
#endif
|
||||
}
|
||||
|
||||
|
||||
@ -125,72 +125,119 @@
|
||||
#define AD9257_VREF_1_6_VAL ((0x3 << AD9257_VREF_OFST) & AD9257_VREF_MSK)
|
||||
#define AD9257_VREF_2_0_VAL ((0x4 << AD9257_VREF_OFST) & AD9257_VREF_MSK)
|
||||
|
||||
int getMaxValidVref() {
|
||||
uint32_t AD9257_Reg = 0x0;
|
||||
uint32_t AD9257_CsMask = 0x0;
|
||||
uint32_t AD9257_ClkMask = 0x0;
|
||||
uint32_t AD9257_DigMask = 0x0;
|
||||
int AD9257_DigOffset = 0x0;
|
||||
|
||||
/**
|
||||
* Set Defines
|
||||
* @param reg spi register
|
||||
* @param cmsk chip select mask
|
||||
* @param clkmsk clock output mask
|
||||
* @param dmsk digital output mask
|
||||
* @param dofst digital output offset
|
||||
*/
|
||||
void AD9257_SetDefines(uint32_t reg, uint32_t cmsk, uint32_t clkmsk, uint32_t dmsk, int dofst) {
|
||||
AD9257_Reg = reg;
|
||||
AD9257_CsMask = cmsk;
|
||||
AD9257_ClkMask = clkmsk;
|
||||
AD9257_DigMask = dmsk;
|
||||
AD9257_DigOffset = dofst;
|
||||
}
|
||||
|
||||
/**
|
||||
* Disable SPI
|
||||
*/
|
||||
void AD9257_Disable() {
|
||||
bus_w(AD9257_Reg, bus_r(AD9257_Reg)
|
||||
| AD9257_CsMask
|
||||
| AD9257_ClkMask
|
||||
&~(AD9257_DigMask));
|
||||
}
|
||||
|
||||
/**
|
||||
* Get max valid vref value
|
||||
* @param get max vref voltage unit (4 for 2.0V)
|
||||
*/
|
||||
int AD9257_GetMaxValidVref() {
|
||||
return 0x4;
|
||||
}
|
||||
|
||||
void setVrefVoltage(int val) {
|
||||
setAdc9257(AD9257_VREF_REG, val);
|
||||
/**
|
||||
* Set vref voltage
|
||||
* @param val voltage to be set (0 for 1.0V, 1 for 1.14V, 2 for 1.33V, 3 for 1.6V, 4 for 2.0V
|
||||
*/
|
||||
void AD9257_SetVrefVoltage(int val) {
|
||||
AD9257_Set(AD9257_VREF_REG, val);
|
||||
}
|
||||
|
||||
void setAdc9257(int addr, int val) {
|
||||
/**
|
||||
* Set SPI reg value
|
||||
* @param codata value to be set
|
||||
*/
|
||||
void AD9257_Set(int addr, int val) {
|
||||
|
||||
u_int32_t codata;
|
||||
codata = val + (addr << 8);
|
||||
FILE_LOG(logINFO, ("\tSetting ADC SPI Register. Wrote 0x%04x at 0x%04x\n", val, addr));
|
||||
serializeToSPI(ADC_SPI_REG, codata, ADC_SERIAL_CS_OUT_MSK, AD9257_ADC_NUMBITS,
|
||||
ADC_SERIAL_CLK_OUT_MSK, ADC_SERIAL_DATA_OUT_MSK, ADC_SERIAL_DATA_OUT_OFST);
|
||||
serializeToSPI(AD9257_Reg, codata, AD9257_CsMask, AD9257_ADC_NUMBITS,
|
||||
AD9257_ClkMask, AD9257_DigMask, AD9257_DigOffset);
|
||||
}
|
||||
|
||||
void prepareADC9257(){
|
||||
FILE_LOG(logINFOBLUE, ("Preparing ADC9257:\n"));
|
||||
/**
|
||||
* Configure
|
||||
*/
|
||||
void AD9257_Configure(){
|
||||
FILE_LOG(logINFOBLUE, ("Configuring ADC9257:\n"));
|
||||
|
||||
//power mode reset
|
||||
FILE_LOG(logINFO, ("\tPower mode reset\n"));
|
||||
setAdc9257(AD9257_POWER_MODE_REG, AD9257_INT_RESET_VAL);
|
||||
AD9257_Set(AD9257_POWER_MODE_REG, AD9257_INT_RESET_VAL);
|
||||
|
||||
//power mode chip run
|
||||
FILE_LOG(logINFO, ("\tPower mode chip run\n"));
|
||||
setAdc9257(AD9257_POWER_MODE_REG, AD9257_INT_CHIP_RUN_VAL);
|
||||
AD9257_Set(AD9257_POWER_MODE_REG, AD9257_INT_CHIP_RUN_VAL);
|
||||
|
||||
// binary offset
|
||||
FILE_LOG(logINFO, ("\tBinary offset\n"));
|
||||
setAdc9257(AD9257_OUT_MODE_REG, AD9257_OUT_BINARY_OFST_VAL);
|
||||
AD9257_Set(AD9257_OUT_MODE_REG, AD9257_OUT_BINARY_OFST_VAL);
|
||||
|
||||
//output clock phase
|
||||
FILE_LOG(logINFO, ("\tOutput clock phase\n")); //FIXME:??
|
||||
setAdc9257(AD9257_OUT_PHASE_REG, AD9257_OUT_CLK_60_VAL);
|
||||
AD9257_Set(AD9257_OUT_PHASE_REG, AD9257_OUT_CLK_60_VAL);
|
||||
|
||||
// lvds-iee reduced , binary offset
|
||||
FILE_LOG(logINFO, ("\tLvds-iee reduced, binary offset\n"));
|
||||
setAdc9257(AD9257_OUT_MODE_REG, AD9257_OUT_LVDS_IEEE_VAL);
|
||||
AD9257_Set(AD9257_OUT_MODE_REG, AD9257_OUT_LVDS_IEEE_VAL);
|
||||
|
||||
// all devices on chip to receive next command
|
||||
FILE_LOG(logINFO, ("\tAll devices on chip to receive next command\n"));
|
||||
setAdc9257(AD9257_DEV_IND_2_REG,
|
||||
AD9257_Set(AD9257_DEV_IND_2_REG,
|
||||
AD9257_CHAN_H_MSK | AD9257_CHAN_G_MSK | AD9257_CHAN_F_MSK | AD9257_CHAN_E_MSK);
|
||||
#ifdef GOTTHARDD
|
||||
setAdc9257(AD9257_DEV_IND_1_REG,
|
||||
AD9257_Set(AD9257_DEV_IND_1_REG,
|
||||
AD9257_CHAN_D_MSK | AD9257_CHAN_C_MSK | AD9257_CHAN_B_MSK | AD9257_CHAN_A_MSK );// FIXME: gotthard setting dco and ifco to off??
|
||||
#else
|
||||
setAdc9257(AD9257_DEV_IND_1_REG,
|
||||
AD9257_Set(AD9257_DEV_IND_1_REG,
|
||||
AD9257_CHAN_D_MSK | AD9257_CHAN_C_MSK | AD9257_CHAN_B_MSK | AD9257_CHAN_A_MSK |
|
||||
AD9257_CLK_CH_DCO_MSK | AD9257_CLK_CH_IFCO_MSK);
|
||||
#endif
|
||||
|
||||
// vref 1.33
|
||||
FILE_LOG(logINFO, ("\tVref 1.33\n"));// FIXME: needed for Gottthard? earlier not set (default 3.0 v)
|
||||
setAdc9257(AD9257_VREF_REG, AD9257_VREF_1_33_VAL);
|
||||
AD9257_Set(AD9257_VREF_REG, AD9257_VREF_1_33_VAL);
|
||||
|
||||
// no test mode
|
||||
FILE_LOG(logINFO, ("\tNo test mode\n"));
|
||||
setAdc9257(AD9257_TEST_MODE_REG, AD9257_TST_OFF_VAL);
|
||||
AD9257_Set(AD9257_TEST_MODE_REG, AD9257_TST_OFF_VAL);
|
||||
|
||||
#ifdef TESTADC
|
||||
FILE_LOG(logINFOBLUE, ("Putting ADC in Test Mode!\n");
|
||||
// mixed bit frequency test mode
|
||||
FILE_LOG(logINFO, ("\tMixed bit frequency test mode\n"));
|
||||
setAdc9257(AD9257_TEST_MODE_REG, AD9257_TST_MXD_BT_FRQ_VAL);
|
||||
AD9257_Set(AD9257_TEST_MODE_REG, AD9257_TST_MXD_BT_FRQ_VAL);
|
||||
#endif
|
||||
|
||||
}
|
||||
|
||||
@ -1,6 +1,22 @@
|
||||
#pragma once
|
||||
|
||||
#include "blackfin.h" /** I2C_CLOCK_MHZ should be defined */
|
||||
#include "blackfin.h"
|
||||
|
||||
/**
|
||||
* To be defined
|
||||
*
|
||||
* (in blackfin.h)
|
||||
* I2C_CLOCK_MHZ
|
||||
*
|
||||
* (RegisterDefs.h)
|
||||
* I2C_SCL_LOW_COUNT_REG
|
||||
* I2C_SCL_HIGH_COUNT_REG
|
||||
* I2C_SDA_HOLD_REG
|
||||
* I2C_CONTROL_REG
|
||||
* I2C_TRANSFER_COMMAND_FIFO_REG
|
||||
* I2C_RX_DATA_FIFO_LEVEL_REG
|
||||
*/
|
||||
|
||||
|
||||
#define I2C_DATA_RATE_KBPS (200)
|
||||
#define I2C_SCL_PERIOD_NS ((1000 * 1000) / I2C_DATA_RATE_KBPS)
|
||||
@ -51,86 +67,81 @@
|
||||
* Configure the I2C core,
|
||||
* Enable core and
|
||||
* Calibrate the calibration register for current readout
|
||||
* @param sclLowCountReg register to set low count of the serial clock
|
||||
* @param sclHighCountReg register to set high count of the serial clock
|
||||
* @param sdaHoldTimeReg register to set hold time of the serial data
|
||||
* @oaram controlReg register to set control reg (bus speed and enabling core)
|
||||
*/
|
||||
void I2C_ConfigureI2CCore(uint32_t sclLowCountReg, uint32_t sclHighCountReg, uint32_t sdaHoldTimeReg, uint32_t controlReg) {
|
||||
FILE_LOG(logINFOBLUE, ("Configuring I2C Core for %d kbps:\n", I2C_DATA_RATE_KBPS));
|
||||
void I2C_ConfigureI2CCore() {
|
||||
FILE_LOG(logINFOBLUE, ("\tConfiguring I2C Core for %d kbps:\n", I2C_DATA_RATE_KBPS));
|
||||
|
||||
FILE_LOG(logINFOBLUE, ("\tSetting SCL Low Period: %d ns (0x%x clocks)\n", I2C_SCL_LOW_PERIOD_NS, I2C_SCL_LOW_COUNT));
|
||||
bus_w(sclLowPeriodReg, (uint32_t)I2C_SCL_LOW_COUNT);
|
||||
bus_w(I2C_SCL_LOW_COUNT_REG, (uint32_t)I2C_SCL_LOW_COUNT);
|
||||
|
||||
FILE_LOG(logINFOBLUE, ("\tSetting SCL High Period: %d ns (0x%x clocks)\n", I2C_SCL_HIGH_PERIOD_NS, I2C_SCL_LOW_COUNT));
|
||||
bus_w(sclHighPeriodReg, (uint32_t)I2C_SCL_LOW_COUNT);
|
||||
bus_w(I2C_SCL_HIGH_COUNT_REG, (uint32_t)I2C_SCL_LOW_COUNT);
|
||||
|
||||
FILE_LOG(logINFOBLUE, ("\tSetting SDA Hold Time: %d ns (0x%x clocks)\n", I2C_SDA_DATA_HOLD_TIME_NS, I2C_SDA_DATA_HOLD_COUNT));
|
||||
bus_w(sdaHoldTimeReg, (uint32_t)I2C_SDA_DATA_HOLD_COUNT);
|
||||
bus_w(I2C_SDA_HOLD_REG, (uint32_t)I2C_SDA_DATA_HOLD_COUNT);
|
||||
|
||||
FILE_LOG(logINFOBLUE, ("\tEnabling core\n"));
|
||||
bus_w(controlReg, I2C_CNTRL_ENBLE_CORE_MSK | I2C_CTRL_BUS_SPEED_FAST_400_VAL);// fixme: (works?)
|
||||
bus_w(I2C_CONTROL_REG, I2C_CTRL_ENBLE_CORE_MSK | I2C_CTRL_BUS_SPEED_FAST_400_VAL);// fixme: (works?)
|
||||
}
|
||||
|
||||
/**
|
||||
* Read register
|
||||
* @param transferCommandReg transfer command fifo register
|
||||
* @param rxDataFifoLevelReg receive data fifo level register
|
||||
* @param deviceId device Id
|
||||
* @param addr register address
|
||||
* @returns value read from register
|
||||
*/
|
||||
uint32_t I2C_Read(uint32_t transferCommandReg, uint32_t rxDataFifoLevelReg, uint32_t devId, uint32_t addr) {
|
||||
uint32_t I2C_Read(uint32_t devId, uint32_t addr) {
|
||||
FILE_LOG(logDEBUG1, ("\tReading from I2C device 0x%x and reg 0x%x\n", devId, addr));
|
||||
// device Id mask
|
||||
uint32_t devIdMask = ((devId << I2C_TFR_CMD_ADDR_OFST) & I2C_TFR_CMD_ADDR_MSK);
|
||||
|
||||
// write I2C ID
|
||||
bus_w(transferCommandReg, (devIdMask & ~(I2C_TFR_CMD_RW_MSK)));
|
||||
bus_w(I2C_TRANSFER_COMMAND_FIFO_REG, (devIdMask & ~(I2C_TFR_CMD_RW_MSK)));
|
||||
|
||||
// write register addr
|
||||
bus_w(transferCommandReg, addr);
|
||||
bus_w(I2C_TRANSFER_COMMAND_FIFO_REG, addr);
|
||||
|
||||
// repeated start with read
|
||||
bus_w(transferCommandReg, (devIdMask | I2C_TFR_CMD_RPTD_STRT_MSK | I2C_TFR_CMD_RW_READ_VAL));
|
||||
bus_w(I2C_TRANSFER_COMMAND_FIFO_REG, (devIdMask | I2C_TFR_CMD_RPTD_STRT_MSK | I2C_TFR_CMD_RW_READ_VAL));
|
||||
|
||||
// continue reading
|
||||
bus_w(transferCommandReg, 0x0);
|
||||
bus_w(I2C_TRANSFER_COMMAND_FIFO_REG, 0x0);
|
||||
|
||||
// stop reading
|
||||
bus_w(transferCommandReg, I2C_TFR_CMD_STOP_MSK);
|
||||
bus_w(I2C_TRANSFER_COMMAND_FIFO_REG, I2C_TFR_CMD_STOP_MSK);
|
||||
|
||||
// read value
|
||||
return bus_r(rxDataFifoLevelReg);
|
||||
return bus_r(I2C_RX_DATA_FIFO_LEVEL_REG);
|
||||
}
|
||||
|
||||
/**
|
||||
* Write register (16 bit value)
|
||||
* @param transferCommandReg transfer command fifo register
|
||||
* @param deviceId device Id
|
||||
* @param addr register address
|
||||
* @param data data to be written (16 bit)
|
||||
*/
|
||||
void I2C_Write(uint32_t transferCommandReg, uint32_t devId, uint32_t addr, uint16_t data) {
|
||||
void I2C_Write(uint32_t devId, uint32_t addr, uint16_t data) {
|
||||
FILE_LOG(logDEBUG1, ("\tWriting data %d to I2C device 0x%x and reg 0x%x\n", data, devId, addr));
|
||||
// device Id mask
|
||||
uint32_t devIdMask = ((devId << I2C_TFR_CMD_ADDR_OFST) & I2C_TFR_CMD_ADDR_MSK);
|
||||
|
||||
// write I2C ID
|
||||
bus_w(transferCommandReg, (devIdMask & ~(I2C_TFR_CMD_RW_MSK)));
|
||||
bus_w(I2C_TRANSFER_COMMAND_FIFO_REG, (devIdMask & ~(I2C_TFR_CMD_RW_MSK)));
|
||||
|
||||
// write register addr
|
||||
bus_w(transferCommandReg, addr);
|
||||
bus_w(I2C_TRANSFER_COMMAND_FIFO_REG, addr);
|
||||
|
||||
// repeated start with write
|
||||
bus_w(transferCommandReg, (devIdMask | I2C_TFR_CMD_RPTD_STRT_MSK & ~(I2C_TFR_CMD_RW_MSK)));
|
||||
bus_w(I2C_TRANSFER_COMMAND_FIFO_REG, (devIdMask | I2C_TFR_CMD_RPTD_STRT_MSK & ~(I2C_TFR_CMD_RW_MSK)));
|
||||
|
||||
uint8_t msb = data & 0xFF00;
|
||||
uint8_t lsb = data & 0x00FF;
|
||||
|
||||
// writing data MSB
|
||||
bus_w(transferCommandReg, ((msb << I2C_TFR_CMD_DATA_FR_WR_OFST) & I2C_TFR_CMD_DATA_FR_WR_MSK));
|
||||
bus_w(I2C_TRANSFER_COMMAND_FIFO_REG, ((msb << I2C_TFR_CMD_DATA_FR_WR_OFST) & I2C_TFR_CMD_DATA_FR_WR_MSK));
|
||||
|
||||
// writing data LSB and stop writing bit
|
||||
bus_w(transferCommandReg, ((lsb << I2C_TFR_CMD_DATA_FR_WR_OFST) & I2C_TFR_CMD_DATA_FR_WR_MSK) | I2C_TFR_CMD_STOP_MSK);
|
||||
bus_w(I2C_TRANSFER_COMMAND_FIFO_REG, ((lsb << I2C_TFR_CMD_DATA_FR_WR_OFST) & I2C_TFR_CMD_DATA_FR_WR_MSK) | I2C_TFR_CMD_STOP_MSK);
|
||||
}
|
||||
|
||||
|
||||
|
||||
@ -2,6 +2,14 @@
|
||||
|
||||
#include "I2C.h"
|
||||
|
||||
/**
|
||||
* To be defined in
|
||||
*
|
||||
* (slsDetectorServer_defs.h)
|
||||
* I2C_SHUNT_RESISTER_OHMS
|
||||
* device ids that are passed as arguments
|
||||
*/
|
||||
|
||||
/** INA226 defines */
|
||||
|
||||
/** Register set */
|
||||
@ -37,13 +45,10 @@
|
||||
|
||||
/**
|
||||
* Configure the I2C core and Enable core
|
||||
* @param sclLowCountReg register to set low count of the serial clock (defined in Registerdefs.h)
|
||||
* @param sclHighCountReg register to set high count of the serial clock (defined in Registerdefs.h)
|
||||
* @param sdaHoldTimeReg register to set hold time of the serial data (defined in Registerdefs.h)
|
||||
* @param controlReg register to set control reg (bus speed and enabling core) (defined in Registerdefs.h)
|
||||
*/
|
||||
void INA226_ConfigureI2CCore(uint32_t sclLowCountReg, uint32_t sclHighCountReg, uint32_t sdaHoldTimeReg, uint32_t controlReg) {
|
||||
I2C_ConfigureI2CCore(sclLowCountReg, sclHighCountReg, sdaHoldTimeReg, controlReg);
|
||||
void INA226_ConfigureI2CCore() {
|
||||
FILE_LOG(logINFO, ("Configuring INA226\n"));
|
||||
I2C_ConfigureI2CCore();
|
||||
}
|
||||
|
||||
/**
|
||||
@ -52,26 +57,24 @@ void INA226_ConfigureI2CCore(uint32_t sclLowCountReg, uint32_t sclHighCountReg,
|
||||
* @param transferCommandReg transfer command fifo register (defined in RegisterDefs.h)
|
||||
* @param deviceId device Id (defined in slsDetectorServer_defs.h)
|
||||
*/
|
||||
void INA226_CalibrateCurrentRegister(uint32_t shuntResisterOhm, uint32_t transferCommandReg, uint32_t deviceId) {
|
||||
void INA226_CalibrateCurrentRegister(uint32_t deviceId) {
|
||||
|
||||
// get calibration value based on shunt resistor
|
||||
uint16_t calVal = INA226_getCalibrationValue(shuntResisterOhm) & INA226_CALIBRATION_MSK;
|
||||
uint16_t calVal = INA226_getCalibrationValue(I2C_SHUNT_RESISTER_OHMS) & INA226_CALIBRATION_MSK;
|
||||
FILE_LOG(logINFO, ("\tWriting to Calibration reg: 0x%0x\n", calVal));
|
||||
|
||||
// calibrate current register
|
||||
I2C_Write(transferCommandReg, deviceId, INA226_CALIBRATION_REG, calVal);
|
||||
I2C_Write(INA226_TRANSFER_COMMAND_FIFO_REG, deviceId, INA226_CALIBRATION_REG, calVal);
|
||||
}
|
||||
|
||||
/**
|
||||
* Read voltage of device
|
||||
* @param transferCommandReg transfer command fifo register (defined in RegisterDefs.h)
|
||||
* @param rxDataFifoLevelReg receive data fifo level register (defined in RegisterDefs.h)
|
||||
* @param deviceId device Id (defined in slsDetectorServer_defs.h)
|
||||
* @param deviceId device Id
|
||||
* @returns voltage in mV
|
||||
*/
|
||||
int INA226_ReadVoltage(uint32_t transferCommandReg, uint32_t rxDataFifoLevelReg, uint32_t deviceId) {
|
||||
int INA226_ReadVoltage(uint32_t deviceId) {
|
||||
FILE_LOG(logDEBUG1, ("\tReading voltage\n"));
|
||||
uint32_t regval = I2C_Read(transferCommandReg, rxDataFifoLevelReg, deviceId, INA226_BUS_VOLTAGE_REG);
|
||||
uint32_t regval = I2C_Read(deviceId, INA226_BUS_VOLTAGE_REG);
|
||||
FILE_LOG(logDEBUG1, ("\tvoltage read: 0x%08x\n", regval));
|
||||
|
||||
// value converted in mv
|
||||
@ -92,22 +95,20 @@ int INA226_ReadVoltage(uint32_t transferCommandReg, uint32_t rxDataFifoLevelReg,
|
||||
|
||||
/**
|
||||
* Read current
|
||||
* @param transferCommandReg transfer command fifo register (defined in RegisterDefs.h)
|
||||
* @param rxDataFifoLevelReg receive data fifo level register (defined in RegisterDefs.h)
|
||||
* @param deviceId device Id (should be defined in slsDetectorServer_defs.h)
|
||||
* @param deviceId device Id
|
||||
* @returns current in mA
|
||||
*/
|
||||
int INA226_ReadCurrent(uint32_t transferCommandReg, uint32_t rxDataFifoLevelReg, uint32_t deviceId) {
|
||||
int INA226_ReadCurrent(uint32_t deviceId) {
|
||||
FILE_LOG(logDEBUG1, ("\tReading current\n"));
|
||||
|
||||
// read shunt voltage register
|
||||
FILE_LOG(logDEBUG1, ("\tReading shunt voltage reg\n"));
|
||||
uint32_t shuntVoltageRegVal = I2C_Read(transferCommandReg, rxDataFifoLevelReg, deviceId, INA226_SHUNT_VOLTAGE_REG);
|
||||
uint32_t shuntVoltageRegVal = I2C_Read(deviceId, INA226_SHUNT_VOLTAGE_REG);
|
||||
FILE_LOG(logDEBUG1, ("\tshunt voltage reg: 0x%08x\n", regval));
|
||||
|
||||
// read calibration register
|
||||
FILE_LOG(logDEBUG1, ("\tReading calibration reg\n"));
|
||||
uint32_t calibrationRegVal = I2C_Read(transferCommandReg, rxDataFifoLevelReg, deviceId, INA226_CALIBRATION_REG);
|
||||
uint32_t calibrationRegVal = I2C_Read(deviceId, INA226_CALIBRATION_REG);
|
||||
FILE_LOG(logDEBUG1, ("\tcalibration reg: 0x%08x\n", regval));
|
||||
|
||||
// value for current
|
||||
|
||||
288
slsDetectorServers/slsDetectorServer/LTC2620.h
Executable file
288
slsDetectorServers/slsDetectorServer/LTC2620.h
Executable file
@ -0,0 +1,288 @@
|
||||
#pragma once
|
||||
|
||||
#include "commonServerFunctions.h" // blackfin.h, ansi.h
|
||||
#include "common.h"
|
||||
|
||||
/* LTC2620 DAC DEFINES */
|
||||
// first 4 bits are 0 as this is a 12 bit dac
|
||||
#define LTC2620_DAC_DATA_OFST (4)
|
||||
#define LTC2620_DAC_DATA_MSK (0x00000FFF << LTC2620_DAC_DATA_OFST)
|
||||
#define LTC2620_DAC_ADDR_OFST (16)
|
||||
#define LTC2620_DAC_ADDR_MSK (0x0000000F << LTC2620_DAC_ADDR_OFST)
|
||||
#define LTC2620_DAC_CMD_OFST (20)
|
||||
#define LTC2620_DAC_CMD_MSK (0x0000000F << LTC2620_DAC_CMD_OFST)
|
||||
|
||||
#define LTC2620_DAC_CMD_WR_IN_VAL ((0x0 << LTC2620_DAC_CMD_OFST) & LTC2620_DAC_CMD_MSK) // write to input register
|
||||
#define LTC2620_DAC_CMD_UPDTE_DAC_VAL ((0x1 << LTC2620_DAC_CMD_OFST) & LTC2620_DAC_CMD_MSK) // update dac (power up)
|
||||
#define LTC2620_DAC_CMD_WR_IN_UPDTE_DAC_VAL ((0x2 << LTC2620_DAC_CMD_OFST) & LTC2620_DAC_CMD_MSK) // write to input register and update dac (power up)
|
||||
#define LTC2620_DAC_CMD_WR_UPDTE_DAC_VAL ((0x3 << LTC2620_DAC_CMD_OFST) & LTC2620_DAC_CMD_MSK) // write to and update dac (power up)
|
||||
#define LTC2620_DAC_CMD_PWR_DWN_VAL ((0x4 << LTC2620_DAC_CMD_OFST) & LTC2620_DAC_CMD_MSK)
|
||||
#define LTC2620_DAC_CMD_NO_OPRTN_VAL ((0xF << LTC2620_DAC_CMD_OFST) & LTC2620_DAC_CMD_MSK)
|
||||
|
||||
#define LTC2620_NUMBITS (24)
|
||||
#define LTC2620_DAISY_CHAIN_NUMBITS (32) // due to shift register FIXME: was 33 earlier
|
||||
#define LTC2620_NUMCHANNELS (8)
|
||||
#define LTC2620_MIN_MV (0)
|
||||
#define LTC2620_MAX_STEPS (2^12) // 4096
|
||||
#define LTC2620_PWR_DOWN_VAL (-100)
|
||||
|
||||
uint32_t LTC2620_Reg = 0x0;
|
||||
uint32_t LTC2620_CsMask = 0x0;
|
||||
uint32_t LTC2620_ClkMask = 0x0;
|
||||
uint32_t LTC2620_DigMask = 0x0;
|
||||
int LTC2620_DigOffset = 0x0;
|
||||
int LTC2620_Ndac = 0;
|
||||
int LTC2620_MaxMV = 0;
|
||||
|
||||
/**
|
||||
* Set Defines
|
||||
* @param reg spi register
|
||||
* @param cmsk chip select mask
|
||||
* @param clkmsk clock output mask
|
||||
* @param dmsk digital output mask
|
||||
* @param dofst digital output offset
|
||||
* @param nd total number of dacs for this board (for dac channel and daisy chain chip id)
|
||||
* @param mv maximum voltage in mV
|
||||
*/
|
||||
void LTC2620_SetDefines(uint32_t reg, uint32_t cmsk, uint32_t clkmsk, uint32_t dmsk, int dofst, int nd, int mv) {
|
||||
LTC2620_Reg = reg;
|
||||
LTC2620_CsMask = cmsk;
|
||||
LTC2620_ClkMask = clkmsk;
|
||||
LTC2620_DigMask = dmsk;
|
||||
LTC2620_DigOffset = dofst;
|
||||
LTC2620_Ndac = nd;
|
||||
LTC2620_MaxMV = mv;
|
||||
}
|
||||
|
||||
/**
|
||||
* Disable SPI
|
||||
*/
|
||||
void LTC2620_Disable() {
|
||||
bus_w(LTC2620_Reg, bus_r(LTC2620_Reg)
|
||||
| LTC2620_CsMask
|
||||
| LTC2620_ClkMask
|
||||
&~(LTC2620_DigMask));
|
||||
}
|
||||
|
||||
/**
|
||||
* Set dac in dac units or mV
|
||||
* @param dacnum dac index
|
||||
* @param val value in dac units or mV
|
||||
* @param mV 0 for dac units and 1 for mV unit
|
||||
* @param dacval pointer to value in dac units
|
||||
* @returns OK or FAIL for success of operation
|
||||
*/
|
||||
int LTC2620_SetDACValue (int dacnum, int val, int mV, int* dacval) {
|
||||
// validate index
|
||||
if (dacnum < 0 || dacnum >= LTC2620_Ndac) {
|
||||
FILE_LOG(logERROR, ("Dac index %d is out of bounds (0 to %d)\n", dacnum, LTC2620_Ndac - 1));
|
||||
return FAIL;
|
||||
}
|
||||
|
||||
// get
|
||||
if (val < 0 && val != LTC2620_PWR_DOWN_VAL)
|
||||
return FAIL;
|
||||
|
||||
// convert to dac or get mV value
|
||||
*dacval = val;
|
||||
int dacmV = val;
|
||||
if (mV) {
|
||||
ret = LTC2620_VoltageToDac(val, dacval);
|
||||
} else if (val >= 0) { // do not convert power down dac val
|
||||
ret = LTC2620_DacToVoltage(val, &dacmV);
|
||||
}
|
||||
|
||||
// conversion out of bounds
|
||||
if (ret == FAIL) {
|
||||
FILE_LOG(logERROR, ("Setting Dac %d %s is out of bounds\n", dacnum, (mV ? "mV" : "dac units")));
|
||||
return FAIL;
|
||||
}
|
||||
|
||||
// set
|
||||
if ( (dacval >= 0) || (dacval == LTC2620_PWR_DOWN_VAL)) {
|
||||
FILE_LOG(logINFO, ("Setting DAC %d: %d dac (%d mV)\n",ind, dacval, dacmV));
|
||||
LTC2620_SetDAC(ind, dacval);
|
||||
}
|
||||
return OK;
|
||||
}
|
||||
|
||||
/**
|
||||
* Convert voltage to dac units
|
||||
* @param voltage value in mv
|
||||
* @param dacval pointer to value converted to dac units
|
||||
* @returns FAIL when voltage outside limits, OK if conversion successful
|
||||
*/
|
||||
int LTC2620_VoltageToDac(int voltage, int* dacval) {
|
||||
return Common_VoltageToDac(voltage, dacval, LTC2620_MIN_MV, LTC2620_MaxMV, LTC2620_MAX_STEPS);
|
||||
}
|
||||
|
||||
/**
|
||||
* Convert dac units to voltage
|
||||
* @param dacval dac units
|
||||
* @param voltage pointer to value converted to mV
|
||||
* @returns FAIL when voltage outside limits, OK if conversion successful
|
||||
*/
|
||||
int LTC2620_DacToVoltage(int dacval, int* voltage) {
|
||||
return Common_VoltageToDac(dacval, voltage, LTC2620_MIN_MV, LTC2620_MaxMV, LTC2620_MAX_STEPS);
|
||||
}
|
||||
|
||||
/**
|
||||
* Configure (obtains dacaddr, command and ichip and calls LTC2620_Set)
|
||||
*/
|
||||
void LTC2620_Configure(){
|
||||
FILE_LOG(logINFOBLUE, ("Configuring LTC2620\n"));
|
||||
|
||||
// dac channel - all channels
|
||||
int addr = LTC2620_DAC_ADDR_MSK;
|
||||
|
||||
// data (any random low value, just writing to power up)
|
||||
int data = 0x6;
|
||||
|
||||
// command
|
||||
int cmd = LTC2620_DAC_CMD_WR_IN_VAL; //FIXME: should be command update and not write(does not power up)
|
||||
// also why do we need to power up (for jctb, we power down next)
|
||||
|
||||
LTC2620_Set(data, addr, cmd, -1);
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Set Dac value (obtains dacaddr, command and ichip and calls LTC2620_Set)
|
||||
* @param dacnum dac number
|
||||
* @param data dac value to set
|
||||
*/
|
||||
void LTC2620_SetDACValue (int dacnum, int data) {
|
||||
FILE_LOG(logDEBUG1, ("\tSetting dac %d to %d\n", dacnum, data));
|
||||
// LTC2620 index
|
||||
int ichip = dacnum / LTC2620_NUMCHANNELS;
|
||||
|
||||
// dac channel
|
||||
int addr = dacnum % LTC2620_NUMCHANNELS;
|
||||
|
||||
// command
|
||||
int cmd = LTC2620_DAC_CMD_WR_UPDTE_DAC_VAL;
|
||||
|
||||
// power down mode, value is ignored
|
||||
if (val == -100) {
|
||||
cmd = LTC2620_DAC_CMD_PWR_DWN_VAL;
|
||||
FILE_LOG(logDEBUG1, ("\tPOWER DOWN\n"));
|
||||
} else {
|
||||
FILE_LOG(logDEBUG1,("\tWrite to Input Register and Update\n"));
|
||||
}
|
||||
|
||||
LTC2620_Set(data, addr, cmd, ichip);
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Sets a single chip (LTC2620_SetSingle) or multiple chip (LTC2620_SetDaisy)
|
||||
* multiple chip is only for ctb where the multiple chips are connected in daisy fashion
|
||||
* @param cmd command to send
|
||||
* @param data dac value to be set
|
||||
* @param dacaddr dac channel number for the chip
|
||||
* @param chipIndex the chip to be set
|
||||
*/
|
||||
void LTC2620_Set(int cmd, int data, int dacaddr, int chipIndex) {
|
||||
// ctb
|
||||
if (LTC2620_Ndac > LTC2620_NUMCHANNELS)
|
||||
LTC2620_SetDaisy(cmd, data, dacaddr, chipIndex);
|
||||
// others
|
||||
else
|
||||
LTC2620_SetSingle(cmd, data, dacaddr);
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Set a single chip (all non ctb detectors use this)
|
||||
* when max dac is 8
|
||||
* @param cmd command
|
||||
* @param data dac value to be set
|
||||
* @param dacaddr dac channel number in chip
|
||||
*/
|
||||
void LTC2620_SetSingle(int cmd, int data, int dacaddr) {
|
||||
FILE_LOG(logDEBUG1, ("\tdac addr:%d, dac value:%d, cmd:%d\n", dacaddr, data, cmd));
|
||||
|
||||
uint32_t codata = (((data << LTC2620_DAC_DATA_OFST) & LTC2620_DAC_DATA_MSK) |
|
||||
((dacaddr << LTC2620_DAC_ADDR_OFST) & LTC2620_DAC_ADDR_MSK) |
|
||||
cmd);
|
||||
|
||||
serializeToSPI (LTC2620_Reg, codata, LTC2620_CsMask, LTC2620_NUMBITS,
|
||||
LTC2620_ClkMask, LTC2620_DigMask, LTC2620_DigOffset);
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Set a single chip (all non ctb detectors use this)
|
||||
* when max dac is 8
|
||||
* @param cmd command
|
||||
* @param data dac value to be set
|
||||
* @param dacaddr dac channel number in chip
|
||||
* @param chipIndex index of the chip
|
||||
*/
|
||||
void LTC2620_SetDaisy(int cmd, int data, int dacaddr, int chipIndex) {
|
||||
|
||||
int nchip = LTC2620_Ndac / LTC2620_NUMCHANNELS;
|
||||
uint32_t valw = 0;
|
||||
int ichip = 0;
|
||||
|
||||
FILE_LOG(logDEBUG1, ("\tdesired chip index:%d, nchip:%d, dac channel:%d, dac value:%d, cmd:%d \n",
|
||||
chipIndex, nchip, dacaddr, data, cmd));
|
||||
|
||||
// data to be bit banged
|
||||
uint32_t codata = (((data << LTC2620_DAC_DATA_OFST) & LTC2620_DAC_DATA_MSK) |
|
||||
((dacaddr << LTC2620_DAC_ADDR_OFST) & LTC2620_DAC_ADDR_MSK) |
|
||||
cmd);
|
||||
|
||||
// select all chips (ctb daisy chain; others 1 chip)
|
||||
FILE_LOG(logDEBUG1, ("\tSelecting LTC2620\n"));
|
||||
SPIChipSelect (&valw, LTC2620_Reg, LTC2620_CsMask, LTC2620_ClkMask, LTC2620_DigMask);
|
||||
|
||||
// send same data to all
|
||||
if (chipIndex < 0) {
|
||||
FILE_LOG(logDEBUG1, ("\tSend same data to all\n"));
|
||||
for (ichip = 0; ichip < nchip; ++ichip) {
|
||||
FILE_LOG(logDEBUG1, ("\tSend to ichip %d\n", ichip));
|
||||
LTC2620_SendDaisyData(&valw, codata);
|
||||
}
|
||||
}
|
||||
|
||||
// send to one chip, nothing to others
|
||||
else {
|
||||
// send nothing to preceding ichips (daisy chain) (if any chips in front of desired chip)
|
||||
for (ichip = 0; ichip < chipIndex; ++ichip) {
|
||||
FILE_LOG(logDEBUG1, ("\tSend nothing to ichip %d\n", ichip));
|
||||
LTC2620_SendDaisyData(&valw, LTC2620_DAC_CMD_NO_OPRTN_VAL);
|
||||
}
|
||||
|
||||
// send data to desired chip
|
||||
FILE_LOG(logDEBUG1, ("\tSend data to ichip %d\n", chipIndex));
|
||||
LTC2620_SendDaisyData(&valw, codata);
|
||||
|
||||
// send nothing to subsequent ichips (daisy chain) (if any chips after desired chip)
|
||||
int ichip = 0;
|
||||
for (ichip = chipIndex + 1; ichip < nchip; ++ichip) {
|
||||
FILE_LOG(logDEBUG1, ("\tSend nothing to ichip %d\n", ichip));
|
||||
LTC2620_SendDaisyData(&valw, LTC2620_DAC_CMD_NO_OPRTN_VAL);
|
||||
}
|
||||
}
|
||||
|
||||
// deselect all chips (ctb daisy chain; others 1 chip)
|
||||
FILE_LOG(logDEBUG1, ("\tDeselecting LTC2620\n"));
|
||||
SPIChipDeselect(&valw, LTC2620_Reg, LTC2620_CsMask, LTC2620_ClkMask);
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* bit bang the data into all the chips daisy fashion
|
||||
* @param valw current value of register while bit banging
|
||||
* @param val data to be sent (data, dac addr and command)
|
||||
*/
|
||||
void LTC2620_SendDaisyData(uint32_t* valw, uint32_t val) {
|
||||
sendDataToSPI(valw, LTC2620_Reg, val, LTC2620_DAISY_CHAIN_NUMBITS,
|
||||
LTC2620_ClkMask, LTC2620_DigMask, LTC2620_DigOffset);
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
@ -2,21 +2,21 @@
|
||||
|
||||
#include "blackfin.h"
|
||||
|
||||
void SPIChipSelect (uint32_t* valw, uint32_t addr, uint32_t csmask) {
|
||||
void SPIChipSelect (uint32_t* valw, uint32_t addr, uint32_t csmask, uint32_t clkmask, uint32_t digoutmask) {
|
||||
|
||||
// start point
|
||||
(*valw) = 0xffffffff; // old board compatibility (not using specific bits)
|
||||
(*valw) = (bus_r(addr) | csmask | clkmask &~(digoutmask));
|
||||
bus_w (addr, (*valw));
|
||||
|
||||
// chip sel bar down
|
||||
(*valw) &= ~csmask; /* todo with test: done a bit different, not with previous value */
|
||||
(*valw) &= ~csmask;
|
||||
bus_w (addr, (*valw));
|
||||
}
|
||||
|
||||
|
||||
void SPIChipDeselect (uint32_t* valw, uint32_t addr, uint32_t csmask, uint32_t clkmask) {
|
||||
// chip sel bar up
|
||||
(*valw) |= csmask; /* todo with test: not done for spi */
|
||||
(*valw) |= csmask;
|
||||
bus_w (addr, (*valw));
|
||||
|
||||
//clk down
|
||||
@ -24,8 +24,8 @@ void SPIChipDeselect (uint32_t* valw, uint32_t addr, uint32_t csmask, uint32_t
|
||||
bus_w (addr, (*valw));
|
||||
|
||||
// stop point = start point of course
|
||||
(*valw) = 0xffffffff; // old board compatibility (not using specific bits)
|
||||
bus_w (addr, (*valw));
|
||||
(*valw) |= csmask;
|
||||
bus_w (addr, (*valw)); //FIXME: for ctb slow adcs, might need to set it to low again
|
||||
}
|
||||
|
||||
void sendDataToSPI (uint32_t* valw, uint32_t addr, uint32_t val, int numbitstosend, uint32_t clkmask, uint32_t digoutmask, int digofset) {
|
||||
@ -47,6 +47,24 @@ void sendDataToSPI (uint32_t* valw, uint32_t addr, uint32_t val, int numbitstose
|
||||
}
|
||||
}
|
||||
|
||||
uint32_t receiveDataFromSPI (uint32_t* valw, uint32_t addr, int numbitstoreceive, uint32_t clkmask, uint32_t readaddr) {
|
||||
uint32_t retval = 0;
|
||||
int i = 0;
|
||||
for (i = 0; i < numbitstoreceive; ++i) {
|
||||
|
||||
// clk down
|
||||
(*valw) &= ~clkmask;
|
||||
bus_w (addr, (*valw));
|
||||
|
||||
// read data (i)
|
||||
retval |= ((bus_r(readaddr) & 0x1) << (numbitstoreceive - 1 - i));
|
||||
|
||||
// clk up
|
||||
(*valw) |= clkmask ;
|
||||
bus_w (addr, (*valw));
|
||||
}
|
||||
return retval;
|
||||
}
|
||||
|
||||
void serializeToSPI(uint32_t addr, uint32_t val, uint32_t csmask, int numbitstosend, uint32_t clkmask, uint32_t digoutmask, int digofset) {
|
||||
if (numbitstosend == 16) {
|
||||
@ -62,3 +80,21 @@ void serializeToSPI(uint32_t addr, uint32_t val, uint32_t csmask, int numbitstos
|
||||
|
||||
SPIChipDeselect(&valw, addr, csmask, clkmask);
|
||||
}
|
||||
|
||||
uint32_t serializeFromSPI(uint32_t addr, uint32_t csmask, int numbitstoreceive, uint32_t clkmask, uint32_t digoutmask, uint32_t readaddr) {
|
||||
|
||||
uint32_t valw;
|
||||
|
||||
SPIChipSelect (&valw, addr, csmask, clkmask, digoutmask);
|
||||
|
||||
uint32_t retval = receiveDataFromSPI(&valw, addr, numbitstoreceive, clkmask, readaddr);
|
||||
|
||||
SPIChipDeselect(&valw, addr, csmask, clkmask);
|
||||
|
||||
if (numbitstoreceive == 16) {
|
||||
FILE_LOG(logDEBUG1, ("Read From SPI Register: 0x%04x\n", retval));
|
||||
} else {
|
||||
FILE_LOG(logDEBUG1, ("Read From SPI Register: 0x%08x\n", retval));
|
||||
}
|
||||
return retval;
|
||||
}
|
||||
|
||||
@ -144,30 +144,23 @@ int setThresholdEnergy(int ev);
|
||||
#endif
|
||||
|
||||
// parameters - dac, adc, hv
|
||||
#if defined(GOTTHARDD) || defined(JUNGFRAUD) || defined (CHIPTESTBOARDD)
|
||||
void serializeToSPI(u_int32_t addr, u_int32_t val, u_int32_t csmask, int numbitstosend, u_int32_t clkmask, u_int32_t digoutmask, int digofset); //commonServerFunction.h
|
||||
void initDac(int dacnum);
|
||||
int voltageToDac(int value);
|
||||
int dacToVoltage(unsigned int digital);
|
||||
#endif
|
||||
#ifdef CHIPTESTBOARDD
|
||||
int generalVoltageToDac(int value, int vmin, int vmax, int check);
|
||||
int generalDacToVoltage(unsigned int digital, int vmin, int vmax, int check);
|
||||
#endif
|
||||
#ifdef GOTTHARDD
|
||||
extern void setAdc9252(int addr, int val); // AD9252.h (old board)
|
||||
extern void AD9252_Set(int addr, int val); // AD9252.h (old board)
|
||||
#endif
|
||||
#if defined(GOTTHARDD) || defined(JUNGFRAUD) || defined(CHIPTESTBOARDD)
|
||||
extern void setAdc9257(int addr, int val); // AD9257.h
|
||||
extern void AD9257_Set(int addr, int val); // AD9257.h
|
||||
#endif
|
||||
#ifdef CHIPTESTBOARDD
|
||||
extern int getMaxValidVref(); // AD9257.h
|
||||
extern void setVrefVoltage(int val) // AD9257.h
|
||||
extern int AD9257_GetMaxValidVref(); // AD9257.h
|
||||
extern void AD9257_SetVrefVoltage(int val) // AD9257.h
|
||||
#endif
|
||||
|
||||
void setDAC(enum DACINDEX ind, int val, int mV, int retval[]);
|
||||
void setDAC(enum DACINDEX ind, int val, int mV);
|
||||
int getDAC(enum DACINDEX ind, int mV);
|
||||
int getMAXDACUnits();
|
||||
#ifdef CHIPTESTBOARDD
|
||||
int isVLimitCompliant(int mV);
|
||||
int checkVLimitCompliant(int mV);
|
||||
int checkVLimitDacCompliant(int dac);
|
||||
int getVLimit();
|
||||
void setVLimit(int l);
|
||||
int isVchipValid(int val);
|
||||
@ -189,8 +182,10 @@ u_int32_t putout(char *s);
|
||||
#endif*/
|
||||
int getADC(enum ADCINDEX ind);
|
||||
#ifdef CHIPTESTBOARDD
|
||||
int getVoltage(int idac);
|
||||
int getCurrent(int idac);
|
||||
extern int INA226_ReadVoltage(uint32_t transferCommandReg, uint32_t rxDataFifoLevelReg, uint32_t deviceId); // INA226.h
|
||||
extern int INA226_ReadCurrent(uint32_t transferCommandReg, uint32_t rxDataFifoLevelReg, uint32_t deviceId); // INA226.h
|
||||
extern int AD7689_GetTemperature(); // AD7689.h
|
||||
extern int AD7689_GetChannel(int ichan); // AD7689.h
|
||||
#endif
|
||||
|
||||
int setHighVoltage(int val);
|
||||
|
||||
@ -571,7 +571,7 @@ int set_dac(int file_des) {
|
||||
ret = OK;
|
||||
memset(mess, 0, sizeof(mess));
|
||||
int args[3] = {-1, -1, -1};
|
||||
int retval[2] = {-1, -1};
|
||||
int retval = -1;
|
||||
|
||||
if (receiveData(file_des, args, sizeof(args), INT32) < 0)
|
||||
return printSocketReadError();
|
||||
@ -719,12 +719,12 @@ int set_dac(int file_des) {
|
||||
// adc vpp
|
||||
#ifdef CHIPTESTBOARDD
|
||||
case ADC_VPP:
|
||||
if (val < 0 || val > getMaxValidVref()) {
|
||||
if (val < 0 || val > AD9257_GetMaxValidVref()) {
|
||||
ret = FAIL;
|
||||
strcpy(mess,"Could not set dac. Adc Vpp value should be between 0 and %d\n", maxValidVref());
|
||||
FILE_LOG(logERROR,(mess));
|
||||
} else {
|
||||
setVrefVoltage(val);
|
||||
AD9257_AD9257_SetVrefVoltage(val);
|
||||
retval = val; // cannot read
|
||||
}
|
||||
break;
|
||||
@ -733,36 +733,36 @@ int set_dac(int file_des) {
|
||||
// io delay
|
||||
#ifdef EIGERD
|
||||
case IO_DELAY:
|
||||
retval[0] = setIODelay(val);
|
||||
FILE_LOG(logDEBUG1, ("IODelay: %d\n", retval[0]));
|
||||
validate(val, retval[0], "set iodelay", DEC);
|
||||
retval = setIODelay(val);
|
||||
FILE_LOG(logDEBUG1, ("IODelay: %d\n", retval));
|
||||
validate(val, retval, "set iodelay", DEC);
|
||||
break;
|
||||
#endif
|
||||
|
||||
// high voltage
|
||||
case HIGH_VOLTAGE:
|
||||
retval[0] = setHighVoltage(val);
|
||||
FILE_LOG(logDEBUG1, ("High Voltage: %d\n", retval[0]));
|
||||
retval = setHighVoltage(val);
|
||||
FILE_LOG(logDEBUG1, ("High Voltage: %d\n", retval));
|
||||
#if defined(JUNGFRAUD) || defined (CHIPTESTBOARDD)
|
||||
validate(val, retval[0], "set high voltage", DEC);
|
||||
validate(val, retval, "set high voltage", DEC);
|
||||
#endif
|
||||
#ifdef GOTTHARDD
|
||||
if (retval[0] == -1) {
|
||||
if (retval == -1) {
|
||||
ret = FAIL;
|
||||
strcpy(mess,"Invalid Voltage. Valid values are 0, 90, 110, 120, 150, 180, 200\n");
|
||||
FILE_LOG(logERROR,(mess));
|
||||
} else
|
||||
validate(val, retval[0], "set high voltage", DEC);
|
||||
validate(val, retval, "set high voltage", DEC);
|
||||
#elif EIGERD
|
||||
if ((retval[0] != SLAVE_HIGH_VOLTAGE_READ_VAL) && (retval[0] < 0)) {
|
||||
if ((retval != SLAVE_HIGH_VOLTAGE_READ_VAL) && (retval < 0)) {
|
||||
ret = FAIL;
|
||||
if (retval[0] == -1)
|
||||
if (retval == -1)
|
||||
sprintf(mess, "Setting high voltage failed. Bad value %d. "
|
||||
"The range is from 0 to 200 V.\n",val);
|
||||
else if (retval[0] == -2)
|
||||
else if (retval == -2)
|
||||
strcpy(mess, "Setting high voltage failed. "
|
||||
"Serial/i2c communication failed.\n");
|
||||
else if (retval[0] == -3)
|
||||
else if (retval == -3)
|
||||
strcpy(mess, "Getting high voltage failed. "
|
||||
"Serial/i2c communication failed.\n");
|
||||
FILE_LOG(logERROR,(mess));
|
||||
@ -781,7 +781,7 @@ int set_dac(int file_des) {
|
||||
ret = FAIL;
|
||||
sprintf(mess,"Could not set power. Power regulator %d should be in mV and not dac units.\n", ind);
|
||||
FILE_LOG(logERROR,(mess));
|
||||
} else if (checkVLimitCompliant() == FAIL) {
|
||||
} else if (checkVLimitCompliant(val) == FAIL) {
|
||||
ret = FAIL;
|
||||
sprintf(mess,"Could not set power. Power regulator %d exceeds voltage limit %d.\n", ind, getVLimit());
|
||||
FILE_LOG(logERROR,(mess));
|
||||
@ -792,9 +792,9 @@ int set_dac(int file_des) {
|
||||
} else {
|
||||
if (val != -1)
|
||||
setPower(serverDacIndex, val);
|
||||
retval[0] = getPower(serverDacIndex);
|
||||
FILE_LOG(logDEBUG1, ("Power regulator(%d): %d\n", ind, retval[0]));
|
||||
validate(val, retval[0], "set power regulator", DEC);
|
||||
retval = getPower(serverDacIndex);
|
||||
FILE_LOG(logDEBUG1, ("Power regulator(%d): %d\n", ind, retval));
|
||||
validate(val, retval, "set power regulator", DEC);
|
||||
}
|
||||
break;
|
||||
|
||||
@ -810,9 +810,9 @@ int set_dac(int file_des) {
|
||||
} else {
|
||||
if (val >= 0) // not letting user set to -100, it will affect setting
|
||||
setVchip(val);
|
||||
retval[0] = getVchip();
|
||||
FILE_LOG(logDEBUG1, ("Vchip: %d\n", retval[0]));
|
||||
validate(val, retval[0], "set vchip", DEC);
|
||||
retval = getVchip();
|
||||
FILE_LOG(logDEBUG1, ("Vchip: %d\n", retval));
|
||||
validate(val, retval, "set vchip", DEC);
|
||||
}
|
||||
break;
|
||||
|
||||
@ -824,9 +824,9 @@ int set_dac(int file_des) {
|
||||
} else {
|
||||
if (val >= 0)
|
||||
setVLimit(val);
|
||||
retval[0] = getVLimit();
|
||||
FILE_LOG(logDEBUG1, ("VLimit: %d\n", retval[0]));
|
||||
validate(val, retval[0], "set vlimit", DEC);
|
||||
retval = getVLimit();
|
||||
FILE_LOG(logDEBUG1, ("VLimit: %d\n", retval));
|
||||
validate(val, retval, "set vlimit", DEC);
|
||||
}
|
||||
break;
|
||||
#endif
|
||||
@ -837,14 +837,14 @@ int set_dac(int file_des) {
|
||||
ret = FAIL;
|
||||
sprintf(mess,"Could not set dac %d to value %d. Allowed limits (0 - %d mV).\n", ind, val, MAX_DAC_VOLTAGE_VALUE);
|
||||
FILE_LOG(logERROR,(mess));
|
||||
} else if (!mV && val > MAX_DAC_UNIT_VALUE ) {
|
||||
} else if (!mV && val > LTC2620_MAX_STEPS ) {
|
||||
ret = FAIL;
|
||||
sprintf(mess,"Could not set dac %d to value %d. Allowed limits (0 - %d dac units).\n", ind, val, MAX_DAC_UNIT_VALUE);
|
||||
sprintf(mess,"Could not set dac %d to value %d. Allowed limits (0 - %d dac units).\n", ind, val, LTC2620_MAX_STEPS);
|
||||
FILE_LOG(logERROR,(mess));
|
||||
} else {
|
||||
#ifdef CHIPTESTBOARDD
|
||||
if ((mV && checkVLimitCompliant() == FAIL) ||
|
||||
(!mv && checkVLimitCompliant(dacToVoltage(val)) == FAIL)) {
|
||||
if ((mV && checkVLimitCompliant(val) == FAIL) ||
|
||||
(!mv && checkVLimitDacCompliant(val) == FAIL)) {
|
||||
ret = FAIL;
|
||||
sprintf(mess,"Could not set dac %d to value %d. "
|
||||
"Exceeds voltage limit %d.\n",
|
||||
@ -875,25 +875,20 @@ int set_dac(int file_des) {
|
||||
#endif
|
||||
//check
|
||||
if (ret == OK) {
|
||||
int temp = 0;
|
||||
if (mV)
|
||||
temp = retval[1];
|
||||
else
|
||||
temp = retval[0];
|
||||
if ((abs(temp-val) <= 5) || val == -1) {
|
||||
if ((abs(retval - val) <= 5) || val == -1) {
|
||||
ret = OK;
|
||||
} else {
|
||||
ret = FAIL;
|
||||
sprintf(mess,"Setting dac %d : wrote %d but read %d\n", serverDacIndex, val, temp);
|
||||
sprintf(mess,"Setting dac %d : wrote %d but read %d\n", serverDacIndex, val, retval);
|
||||
FILE_LOG(logERROR,(mess));
|
||||
}
|
||||
}
|
||||
FILE_LOG(logDEBUG1, ("Dac (%d): %d dac units and %d mV\n", serverDacIndex, retval[0], retval[1]));
|
||||
FILE_LOG(logDEBUG1, ("Dac (%d): %d %s\n", serverDacIndex, retval, (mv ? "mV" : "dac units")));
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
return Server_SendResult(file_des, INT32, UPDATE, retval, sizeof(retval));
|
||||
return Server_SendResult(file_des, INT32, UPDATE, &retval, sizeof(retval));
|
||||
}
|
||||
|
||||
|
||||
@ -2664,12 +2659,12 @@ int write_adc_register(int file_des) {
|
||||
// only set
|
||||
if (Server_VerifyLock() == OK) {
|
||||
#ifdef JUNGFRAUD
|
||||
setAdc9257(addr, val);
|
||||
AD9257_Set(addr, val);
|
||||
#elif GOTTHARDD
|
||||
if (getBoardRevision() == 1) {
|
||||
setAdc9252(addr, val);
|
||||
AD9252_Set(addr, val);
|
||||
} else {
|
||||
setAdc9257(addr, val);
|
||||
AD9257_Set(addr, val);
|
||||
}
|
||||
#endif
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user