int AdcInit(void) {
XSysMon_Config *ConfigPtr;
int Status;
ConfigPtr = XSysMon_LookupConfig(SYSMON_DEVICE_ID);
if (ConfigPtr == NULL) {
return XST_FAILURE;
}
XSysMon_CfgInitialize(SysMonInstPtr, ConfigPtr, ConfigPtr->BaseAddress);
XSysMon_SetSequencerMode(SysMonInstPtr, XSM_SEQ_MODE_SAFE);
XSysMon_SetAlarmEnables(SysMonInstPtr, 0x0);
XSysMon_SetAvg(SysMonInstPtr, XSM_AVG_0_SAMPLES);
Status = XSysMon_SetSeqInputMode(SysMonInstPtr, XSM_SEQ_CH_AUX00);
if (Status != XST_SUCCESS) {
return XST_FAILURE;
}
Status = XSysMon_SetSeqAcqTime(SysMonInstPtr,
XSM_SEQ_CH_AUX00 | XSM_SEQ_CH_AUX06 | XSM_SEQ_CH_AUX07
| XSM_SEQ_CH_AUX14 | XSM_SEQ_CH_AUX15);
if (Status != XST_SUCCESS) {
return XST_FAILURE;
}
Status = XSysMon_SetSeqChEnables(SysMonInstPtr,
XSM_SEQ_CH_AUX00 | XSM_SEQ_CH_AUX06 | XSM_SEQ_CH_AUX07
| XSM_SEQ_CH_AUX14 | XSM_SEQ_CH_AUX15);
if (Status != XST_SUCCESS) {
return XST_FAILURE;
}
XSysMon_SetAdcClkDivisor(SysMonInstPtr, 32);
XSysMon_SetCalibEnables(SysMonInstPtr,
XSM_CFR1_CAL_PS_GAIN_OFFSET_MASK
| XSM_CFR1_CAL_ADC_GAIN_OFFSET_MASK);
XSysMon_SetSequencerMode(SysMonInstPtr, XSM_SEQ_MODE_CONTINPASS);
XSysMon_GetStatus(SysMonInstPtr);
while ((XSysMon_GetStatus(SysMonInstPtr) & XSM_SR_EOS_MASK)
!= XSM_SR_EOS_MASK);
return 0;
}
/**
*
* This function runs a test on the System Monitor/ADC device using the
* driver APIs.
*
* The function does the following tasks:
* - Initiate the System Monitor/ADC device driver instance
* - Run self-test on the device
* - Reset the device
* - Set up alarm for VCCINT
* - Set up the configuration registers for single channel continuous mode
* for VCCINT channel
* - Setup interrupt system
* - Enable interrupts
* - Wait until the VCCINT alarm interrupt occurs
*
* @param IntcInstancePtr is a pointer to the Interrupt Controller
* driver Instance.
* @param SysMonInstPtr is a pointer to the XSysMon driver Instance.
* @param SysMonDeviceId is the XPAR_<SYSMON_ADC_instance>_DEVICE_ID value
* from xparameters.h.
* @param SysMonIntrId is
* XPAR_<INTC_instance>_<SYSMON_ADC_instance>_VEC_ID
* value from xparameters.h
*
* @return
* - XST_SUCCESS if the example has completed successfully.
* - XST_FAILURE if the example has failed.
*
* @note This function may never return if no interrupt occurs.
*
****************************************************************************/
int SysMonSingleChannelIntrExample(XIntc* IntcInstancePtr,
XSysMon* SysMonInstPtr,
u16 SysMonDeviceId,
u16 SysMonIntrId)
{
int Status;
XSysMon_Config *ConfigPtr;
u16 VccintData;
u32 IntrStatus;
/*
* Initialize the SysMon driver.
*/
ConfigPtr = XSysMon_LookupConfig(SysMonDeviceId);
if (ConfigPtr == NULL) {
return XST_FAILURE;
}
XSysMon_CfgInitialize(SysMonInstPtr, ConfigPtr, ConfigPtr->BaseAddress);
/*
* Self Test the System Monitor/ADC device.
*/
Status = XSysMon_SelfTest(SysMonInstPtr);
if (Status != XST_SUCCESS) {
return XST_FAILURE;
}
/*
* Set the ADCCLK frequency equal to 1/32 of System clock for the System
* Monitor/ADC in the Configuration Register 2.
*/
XSysMon_SetAdcClkDivisor(SysMonInstPtr, 32);
/*
* Set the sequencer in Single channel mode.
*/
XSysMon_SetSequencerMode(SysMonInstPtr, XSM_SEQ_MODE_SINGCHAN);
/*
* Set the configuration registers for single channel continuous mode
* of operation for the VCCINT channel.
*/
Status= XSysMon_SetSingleChParams(SysMonInstPtr, XSM_CH_VCCINT,
FALSE, FALSE, FALSE);
if(Status != XST_SUCCESS) {
return XST_FAILURE;
}
/*
* Disable all the alarms in the Configuration Register 1.
*/
XSysMon_SetAlarmEnables(SysMonInstPtr, 0x0);
/*
* Set up Alarm threshold registers for the VCCINT
* High limit and lower limit so that the alarm does not occur.
*/
XSysMon_SetAlarmThreshold(SysMonInstPtr, XSM_ATR_VCCINT_UPPER, 0xFFFF);
XSysMon_SetAlarmThreshold(SysMonInstPtr, XSM_ATR_VCCINT_LOWER, 0x0);
/*
* Setup the interrupt system.
*/
Status = SysMonSetupInterruptSystem(IntcInstancePtr,
SysMonInstPtr,
SysMonIntrId);
if (Status != XST_SUCCESS) {
return XST_FAILURE;
}
/*
* Clear any bits set in the Interrupt Status Register.
*/
IntrStatus = XSysMon_IntrGetStatus(SysMonInstPtr);
XSysMon_IntrClear(SysMonInstPtr, IntrStatus);
/*
* Enable EOC interrupt and Alarm 1 interrupt for on-chip VCCINT.
*/
XSysMon_IntrEnable(SysMonInstPtr, XSM_IPIXR_EOC_MASK |
XSM_IPIXR_VCCINT_MASK);
/*
* Enable global interrupt of System Monitor.
*/
XSysMon_IntrGlobalEnable(SysMonInstPtr);
/*
* Wait till the End of Conversion occurs.
*/
EocFlag = FALSE; /* Clear the EOC Flag */
while (EocFlag != TRUE);
/*
* Read the ADC converted Data from the data registers for VCCINT.
*/
VccintData = XSysMon_GetAdcData(SysMonInstPtr, XSM_CH_VCCINT);
/*
* Set up Alarm threshold registers for the VCCINT
* High limit and lower limit so that the alarm occurs.
*/
XSysMon_SetAlarmThreshold(SysMonInstPtr, XSM_ATR_VCCINT_UPPER,
VccintData - 0x007F);
XSysMon_SetAlarmThreshold(SysMonInstPtr, XSM_ATR_VCCINT_LOWER,
VccintData - 0x007F);
VccintIntr = FALSE; /* Clear the flag */
/*
* Enable Alarm 1 for VCCINT
*/
XSysMon_SetAlarmEnables(SysMonInstPtr, XSM_CFR1_ALM_VCCINT_MASK);
/*
* Wait until an Alarm 1 interrupt occurs.
*/
while (1) {
if (VccintIntr == TRUE) {
/*
* Alarm 1 - VCCINT alarm interrupt has occurred.
* The required processing should be put here.
*/
break;
}
}
/*
* Disable global interrupt of System Monitor.
*/
XSysMon_IntrGlobalDisable(SysMonInstPtr);
return XST_SUCCESS;
}
/**
*
* This function runs a test on the System Monitor/ADC device using the
* driver APIs.
* This function does the following tasks:
* - Initiate the System Monitor device driver instance
* - Run self-test on the device
* - Setup alarms for on-chip temperature and VCCAUX
* - Setup the sequence registers to continuously monitor on-chip
* temperature and VCCAUX
* - Setup configuration registers to start the sequence
* - Read latest on-chip temperature and VCCAUX, as well as their maximum
* and minimum values. Also check if alarm(s) are set
*
* @param SysMonDeviceId is the XPAR_<SYSMON_ADC_instance>_DEVICE_ID value
* from xparameters.h.
* @param Temp is an output parameter, it is a pointer through which the
* current temperature value is returned to the main function.
*
* @return
* - XST_SUCCESS if the example has completed successfully.
* - XST_FAILURE if the example has failed.
*
* @note None
*
****************************************************************************/
int SysMonPolledExample(u16 SysMonDeviceId, int *Temp)
{
int Status;
volatile u32 Value;
XSysMon_Config *ConfigPtr;
u16 TempData;
u16 VccauxData;
XSysMon *SysMonInstPtr = &SysMonInst;
/*
* Initialize the SysMon driver.
*/
ConfigPtr = XSysMon_LookupConfig(SysMonDeviceId);
if (ConfigPtr == NULL) {
return XST_FAILURE;
}
XSysMon_CfgInitialize(SysMonInstPtr, ConfigPtr,
ConfigPtr->BaseAddress);
/*
* Self Test the System Monitor/ADC device
*/
Status = XSysMon_SelfTest(SysMonInstPtr);
if (Status != XST_SUCCESS) {
return XST_FAILURE;
}
/*
* Disable the Channel Sequencer before configuring the Sequence
* registers.
*/
XSysMon_SetSequencerMode(SysMonInstPtr, XSM_SEQ_MODE_SAFE);
/*
* Setup the Averaging to be done for the channels in the
* Configuration 0 register as 16 samples:
*/
XSysMon_SetAvg(SysMonInstPtr, XSM_AVG_16_SAMPLES);
/*
* Setup the Sequence register for 1st Auxiliary channel
* Setting is:
* - Add acquisition time by 6 ADCCLK cycles.
* - Bipolar Mode
*
* Setup the Sequence register for 16th Auxiliary channel
* Setting is:
* - Add acquisition time by 6 ADCCLK cycles.
* - Unipolar Mode
*/
Status = XSysMon_SetSeqInputMode(SysMonInstPtr, XSM_SEQ_CH_AUX00);
if (Status != XST_SUCCESS) {
return XST_FAILURE;
}
Status = XSysMon_SetSeqAcqTime(SysMonInstPtr, XSM_SEQ_CH_AUX15 |
XSM_SEQ_CH_AUX00);
if (Status != XST_SUCCESS) {
return XST_FAILURE;
}
/*
* Enable the averaging on the following channels in the Sequencer
* registers:
* - On-chip Temperature
* - On-chip VCCAUX supply sensor
* - 1st Auxiliary Channel
* - 16th Auxiliary Channel
*/
Status = XSysMon_SetSeqAvgEnables(SysMonInstPtr, XSM_SEQ_CH_TEMP |
XSM_SEQ_CH_VCCAUX |
XSM_SEQ_CH_AUX00 |
XSM_SEQ_CH_AUX15);
if (Status != XST_SUCCESS) {
return XST_FAILURE;
}
/*
* Enable the following channels in the Sequencer registers:
* - On-chip Temperature
* - On-chip VCCAUX supply sensor
* - 1st Auxiliary Channel
* - 16th Auxiliary Channel
*/
Status = XSysMon_SetSeqChEnables(SysMonInstPtr, XSM_SEQ_CH_TEMP |
XSM_SEQ_CH_VCCAUX |
XSM_SEQ_CH_AUX00 |
XSM_SEQ_CH_AUX15);
if (Status != XST_SUCCESS) {
return XST_FAILURE;
}
/*
* Set the ADCCLK frequency equal to 1/32 of System clock for the System
* Monitor/ADC in the Configuration Register 2.
*/
XSysMon_SetAdcClkDivisor(SysMonInstPtr, 32);
/*
* Enable the Channel Sequencer in continuous sequencer cycling mode.
*/
XSysMon_SetSequencerMode(SysMonInstPtr, XSM_SEQ_MODE_CONTINPASS);
/*
* Wait till the End of Sequence occurs
*/
XSysMon_GetStatus(SysMonInstPtr); /* Clear the old status */
while ((XSysMon_GetStatus(SysMonInstPtr) & XSM_SR_EOS_MASK) !=
XSM_SR_EOS_MASK);
/*
* Disable all the alarms in the Configuration Register 1
*/
XSysMon_SetAlarmEnables(SysMonInstPtr, 0x0);
/*
* Read the ADC converted Data from the data registers for on-chip
* temperature and on-chip VCCAUX
*/
TempData = XSysMon_GetAdcData(SysMonInstPtr, XSM_CH_TEMP);
VccauxData = XSysMon_GetAdcData(SysMonInstPtr, XSM_CH_VCCAUX);
/*
* Convert the ADC data into temperature
*/
*Temp = XSysMon_RawToTemperature(TempData);
/*
* Set up Alarm threshold registers for
* On-chip Temperature High limit
* On-chip Temperature Low limit
* VCCAUX High limit
* VCCAUX Low limit
*/
XSysMon_SetAlarmThreshold(SysMonInstPtr, XSM_ATR_TEMP_UPPER,
TempData - 0x007F);
XSysMon_SetAlarmThreshold(SysMonInstPtr, XSM_ATR_TEMP_LOWER,
TempData - 0x007F);
XSysMon_SetAlarmThreshold(SysMonInstPtr, XSM_ATR_VCCAUX_UPPER,
VccauxData - 0x007F);
XSysMon_SetAlarmThreshold(SysMonInstPtr, XSM_ATR_VCCAUX_LOWER,
VccauxData + 0x007F);
/*
* Enable Alarm 0 for on-chip temperature and Alarm 2 for on-chip
* VCCAUX in the Configuration Register 1.
*/
XSysMon_SetAlarmEnables(SysMonInstPtr, (XSM_CFR1_ALM_VCCAUX_MASK |
XSM_CFR1_ALM_TEMP_MASK));
/*
* Enable the Channel Sequencer in continuous cycling mode.
*/
XSysMon_SetSequencerMode(SysMonInstPtr, XSM_SEQ_MODE_CONTINPASS);
/*
* Read the current value of on-chip Temperature.
*/
Value = XSysMon_GetAdcData(SysMonInstPtr, XSM_CH_TEMP);
/*
* Read the Maximum value of on-chip Temperature.
*/
Value = XSysMon_GetMinMaxMeasurement(SysMonInstPtr, XSM_MAX_TEMP);
/*
* Read the Minimum value of on-chip Temperature.
*/
Value = XSysMon_GetMinMaxMeasurement(SysMonInstPtr, XSM_MIN_TEMP);
/*
* Check if alarm for on-chip temperature is set.
*/
Value = XSysMon_GetAlarmOutputStatus(SysMonInstPtr) & XSM_AOR_TEMP_MASK;
if (Value) {
/*
* Alarm for on-chip temperature is set.
* The required processing should be put here.
*/
}
/*
* Read the current value of on-chip VCCAUX.
*/
Value = XSysMon_GetAdcData(SysMonInstPtr, XSM_CH_VCCAUX);
/*
* Read the Maximum value of on-chip VCCAUX.
*/
Value = XSysMon_GetMinMaxMeasurement(SysMonInstPtr, XSM_MAX_VCCAUX);
/*
* Read the Minimum value of on-chip VCCAUX.
*/
Value = XSysMon_GetMinMaxMeasurement(SysMonInstPtr, XSM_MIN_VCCAUX);
/*
* Check if alarm for on-chip VCCAUX is set.
*/
Value = XSysMon_GetAlarmOutputStatus(SysMonInstPtr) &
XSM_AOR_VCCAUX_MASK;
if (Value) {
/*
* Alarm for on-chip VCCAUX is set.
* The required processing should be put here.
*/
}
return XST_SUCCESS;
}
/**
*
* This function runs a test on the System Monitor/ADC device using the
* driver APIs.
*
* The function does the following tasks:
* - Initiate the System Monitor/ADC device driver instance
* - Run self-test on the device
* - Reset the device
* - Set up alarms for on-chip temperature and VCCAUX
* - Set up sequence registers to continuously monitor on-chip temperature
* and VCCAUX
* - Setup interrupt system
* - Enable interrupts
* - Set up configuration registers to start the sequence
* - Wait until temperature alarm interrupt or VCCAUX alarm interrupt
* occurs
*
* @param IntcInstancePtr is a pointer to the Interrupt Controller
* driver Instance.
* @param SysMonInstPtr is a pointer to the XSysMon driver Instance.
* @param SysMonDeviceId is the XPAR_<SYSMON_ADC_instance>_DEVICE_ID value
* from xparameters.h.
* @param SysMonIntrId is
* XPAR_<INTC_instance>_<SYSMON_ADC_instance>_VEC_ID value from
* xparameters.h
* @param Temp is an output parameter, it is a pointer through which the
* current temperature value is returned to the main function.
*
* @return
* - XST_SUCCESS if the example has completed successfully.
* - XST_FAILURE if the example has failed.
*
* @note This function may never return if no interrupt occurs.
*
****************************************************************************/
int SysMonIntrExample(XIntc* IntcInstancePtr, XSysMon* SysMonInstPtr,
u16 SysMonDeviceId, u16 SysMonIntrId, int *Temp)
{
int Status;
XSysMon_Config *ConfigPtr;
u16 TempData;
u16 VccauxData;
u32 IntrStatus;
/*
* Initialize the SysMon driver.
*/
ConfigPtr = XSysMon_LookupConfig(SysMonDeviceId);
if (ConfigPtr == NULL) {
return XST_FAILURE;
}
XSysMon_CfgInitialize(SysMonInstPtr, ConfigPtr, ConfigPtr->BaseAddress);
/*
* Self Test the System Monitor/ADC device.
*/
Status = XSysMon_SelfTest(SysMonInstPtr);
if (Status != XST_SUCCESS) {
return XST_FAILURE;
}
/*
* Disable the Channel Sequencer before configuring the Sequence
* registers.
*/
XSysMon_SetSequencerMode(SysMonInstPtr, XSM_SEQ_MODE_SAFE);
/*
* Setup the Averaging to be done for the channels in the
* Configuration 0 register as 16 samples:
*/
XSysMon_SetAvg(SysMonInstPtr, XSM_AVG_16_SAMPLES);
/*
* Setup the Sequence register for 1st Auxiliary channel
* Setting is:
* - Add acquisition time by 6 ADCCLK cycles.
* - Bipolar Mode
*
* Setup the Sequence register for 16th Auxiliary channel
* Setting is:
* - Add acquisition time by 6 ADCCLK cycles.
* - Unipolar Mode
*/
Status = XSysMon_SetSeqInputMode(SysMonInstPtr, XSM_SEQ_CH_AUX00);
if (Status != XST_SUCCESS) {
return XST_FAILURE;
}
Status = XSysMon_SetSeqAcqTime(SysMonInstPtr, XSM_SEQ_CH_AUX15 |
XSM_SEQ_CH_AUX00);
if (Status != XST_SUCCESS) {
return XST_FAILURE;
}
/*
* Enable the averaging on the following channels in the Sequencer
* registers:
* - On-chip Temperature
* - On-chip VCCAUX supply sensor
* - 1st Auxiliary Channel
* - 16th Auxiliary Channel
*/
Status = XSysMon_SetSeqAvgEnables(SysMonInstPtr, XSM_SEQ_CH_TEMP |
XSM_SEQ_CH_VCCAUX |
XSM_SEQ_CH_AUX00 |
XSM_SEQ_CH_AUX15);
if (Status != XST_SUCCESS) {
return XST_FAILURE;
}
/*
* Enable the following channels in the Sequencer registers:
* - On-chip Temperature
* - On-chip VCCAUX supply sensor
* - 1st Auxiliary Channel
* - 16th Auxiliary Channel
*/
Status = XSysMon_SetSeqChEnables(SysMonInstPtr, XSM_SEQ_CH_TEMP |
XSM_SEQ_CH_VCCAUX |
XSM_SEQ_CH_AUX00 |
XSM_SEQ_CH_AUX15);
if (Status != XST_SUCCESS) {
return XST_FAILURE;
}
/*
* Set the ADCCLK frequency equal to 1/32 of System clock for the System
* Monitor/ADC in the Configuration Register 2.
*/
XSysMon_SetAdcClkDivisor(SysMonInstPtr, 32);
/*
* Enable the Channel Sequencer in continuous sequencer cycling mode.
*/
XSysMon_SetSequencerMode(SysMonInstPtr, XSM_SEQ_MODE_CONTINPASS);
/*
* Wait till the End of Sequence occurs
*/
XSysMon_GetStatus(SysMonInstPtr); /* Clear the old status */
while ((XSysMon_GetStatus(SysMonInstPtr) & XSM_SR_EOS_MASK) !=
XSM_SR_EOS_MASK);
/*
* Read the ADC converted Data from the data registers for on-chip
* temperature and on-chip VCCAUX voltage.
*/
TempData = XSysMon_GetAdcData(SysMonInstPtr, XSM_CH_TEMP);
VccauxData = XSysMon_GetAdcData(SysMonInstPtr, XSM_CH_VCCAUX);
/*
* Convert the ADC data into temperature
*/
*Temp = XSysMon_RawToTemperature(TempData);
/*
* Disable all the alarms in the Configuration Register 1.
*/
XSysMon_SetAlarmEnables(SysMonInstPtr, 0x0);
/*
* Set up Alarm threshold registers for the on-chip temperature and
* VCCAUX High limit and lower limit so that the alarms DONOT occur.
*/
XSysMon_SetAlarmThreshold(SysMonInstPtr, XSM_ATR_TEMP_UPPER, 0xFFFF);
XSysMon_SetAlarmThreshold(SysMonInstPtr, XSM_ATR_TEMP_LOWER, 0xFFFF);
XSysMon_SetAlarmThreshold(SysMonInstPtr, XSM_ATR_VCCAUX_UPPER, 0xFFFF);
XSysMon_SetAlarmThreshold(SysMonInstPtr, XSM_ATR_VCCAUX_LOWER, 0x0);
/*
* Setup the interrupt system.
*/
Status = SysMonSetupInterruptSystem(IntcInstancePtr,
SysMonInstPtr,
SysMonIntrId);
if (Status != XST_SUCCESS) {
return XST_FAILURE;
}
/*
* Clear any bits set in the Interrupt Status Register.
*/
IntrStatus = XSysMon_IntrGetStatus(SysMonInstPtr);
XSysMon_IntrClear(SysMonInstPtr, IntrStatus);
/*
* Enable Alarm 0 interrupt for on-chip temperature and Alarm 2
* interrupt for on-chip VCCAUX.
*/
XSysMon_IntrEnable(SysMonInstPtr,
XSM_IPIXR_TEMP_MASK |
XSM_IPIXR_VCCAUX_MASK);
/*
* Enable global interrupt of System Monitor.
*/
XSysMon_IntrGlobalEnable(SysMonInstPtr);
/*
* Set up Alarm threshold registers for
* On-chip Temperature High limit
* On-chip Temperature Low limit
* VCCAUX High limit
* VCCAUX Low limit
*/
XSysMon_SetAlarmThreshold(SysMonInstPtr, XSM_ATR_TEMP_UPPER,
TempData - 0x007F);
XSysMon_SetAlarmThreshold(SysMonInstPtr, XSM_ATR_TEMP_LOWER,
TempData - 0x007F);
XSysMon_SetAlarmThreshold(SysMonInstPtr, XSM_ATR_VCCAUX_UPPER,
VccauxData - 0x007F);
XSysMon_SetAlarmThreshold(SysMonInstPtr, XSM_ATR_VCCAUX_LOWER,
VccauxData + 0x007F);
/*
* Enable Alarm 0 for on-chip temperature and Alarm 2 for on-chip
* VCCAUX in the Configuration Register 1.
*/
XSysMon_SetAlarmEnables(SysMonInstPtr, (XSM_CFR1_ALM_VCCAUX_MASK |
XSM_CFR1_ALM_TEMP_MASK));
/*
* Wait until an Alarm 0 or Alarm 2 interrupt occurs.
*/
while (1) {
if (TemperatureIntr == TRUE) {
/*
* Alarm 0 - Temperature alarm interrupt has occurred.
* The required processing should be put here.
*/
break;
}
if (VccauxIntr == TRUE) {
/*
* Alarm 2 - VCCAUX alarm interrupt has occurred.
* The required processing should be put here.
*/
break;
}
}
/*
* Disable global interrupt of System Monitor.
*/
XSysMon_IntrGlobalDisable(SysMonInstPtr);
return XST_SUCCESS;
}
int SysMonIntrExample(XIntc* IntcInstancePtr, XSysMon* SysMonInstPtr,
u16 SysMonDeviceId, u16 SysMonIntrId, int *Temp)
{
int Status;
XSysMon_Config *ConfigPtr;
u32 TempData;
u32 VccauxData;
u32 VccintData;
u32 IntrStatus;
int i, j;
unsigned int whole1, thousandths1;
unsigned int whole2, thousandths2;
unsigned int whole3, thousandths3;
/*
* Initialize the SysMon driver.
*/
//xil_printf("XSysMon intr example\r\n");
ConfigPtr = XSysMon_LookupConfig(SysMonDeviceId);
if (ConfigPtr == NULL) {
return XST_FAILURE;
}
//xil_printf("XSysMon_CfgInitialize\r\n");
XSysMon_CfgInitialize(SysMonInstPtr, ConfigPtr, ConfigPtr->BaseAddress);
/*
* Self Test the System Monitor/ADC device.
*/
//xil_printf("XSysMon_SelfTest\r\n");
Status = XSysMon_SelfTest(SysMonInstPtr);
if (Status != XST_SUCCESS) {
xil_printf("XSysMon_SelfTest failed\r\n");
return XST_FAILURE;
}
/*
* Disable the Channel Sequencer before configuring the Sequence
* registers.
*/
XSysMon_SetSequencerMode(SysMonInstPtr, XSM_SEQ_MODE_SINGCHAN);
/*
* Setup the Averaging to be done for the channels in the
* Configuration 0 register as 16 samples:
*/
XSysMon_SetAvg(SysMonInstPtr, XSM_AVG_16_SAMPLES);
#if 0
/*
* Setup the Sequence register for 1st Auxiliary channel
* Setting is:
* - Add acquisition time by 6 ADCCLK cycles.
* - Bipolar Mode
*
* Setup the Sequence register for 16th Auxiliary channel
* Setting is:
* - Add acquisition time by 6 ADCCLK cycles.
* - Unipolar Mode
*/
Status = XSysMon_SetSeqInputMode(SysMonInstPtr, XSM_SEQ_CH_AUX00);
if (Status != XST_SUCCESS) {
return XST_FAILURE;
}
Status = XSysMon_SetSeqAcqTime(SysMonInstPtr, XSM_SEQ_CH_AUX15 |
XSM_SEQ_CH_AUX00);
if (Status != XST_SUCCESS) {
return XST_FAILURE;
}
#endif
/*
* Enable the averaging on the following channels in the Sequencer
* registers:
* - On-chip Temperature
* - On-chip VCCAUX supply sensor
* - 1st Auxiliary Channel
* - 16th Auxiliary Channel
*/
Status = XSysMon_SetSeqAvgEnables(SysMonInstPtr, XSM_SEQ_CH_TEMP |
/* XSM_SEQ_CH_AUX00 | */
/* XSM_SEQ_CH_AUX15 | */
XSM_SEQ_CH_VCCINT |
XSM_SEQ_CH_VCCAUX );
if (Status != XST_SUCCESS) {
return XST_FAILURE;
}
/*
* Enable the following channels in the Sequencer registers:
* - On-chip Temperature
* - On-chip VCCAUX supply sensor
* - 1st Auxiliary Channel
* - 16th Auxiliary Channel
*/
Status = XSysMon_SetSeqChEnables(SysMonInstPtr, XSM_SEQ_CH_TEMP |
/* XSM_SEQ_CH_AUX00 | */
/* XSM_SEQ_CH_AUX15 | */
XSM_SEQ_CH_VCCINT |
XSM_SEQ_CH_VCCAUX );
if (Status != XST_SUCCESS) {
return XST_FAILURE;
}
/*
* Set the ADCCLK frequency equal to 1/32 of System clock for the System
* Monitor/ADC in the Configuration Register 2.
*/
XSysMon_SetAdcClkDivisor(SysMonInstPtr, 32);
/*
* Enable the Channel Sequencer in continuous sequencer cycling mode.
*/
XSysMon_SetSequencerMode(SysMonInstPtr, XSM_SEQ_MODE_CONTINPASS);
/*
* Disable all the alarms in the Configuration Register 1.
*/
XSysMon_SetAlarmEnables(SysMonInstPtr, 0x0);
/*
* Wait till the End of Sequence occurs
*/
XSysMon_GetStatus(SysMonInstPtr); /* Clear the old status */
i = 0;
while(i < 10)
{
if((XSysMon_GetStatus(SysMonInstPtr) & XSM_SR_EOS_MASK) !=
XSM_SR_EOS_MASK)
continue;
/*
* Read the ADC converted Data from the data registers for on-chip
* temperature and on-chip VCCAUX voltage.
*/
TempData = XSysMon_GetAdcData(SysMonInstPtr, XSM_CH_TEMP);
VccauxData = XSysMon_GetAdcData(SysMonInstPtr, XSM_CH_VCCAUX);
VccintData = XSysMon_GetAdcData(SysMonInstPtr, XSM_CH_VCCINT);
/*
* Convert the ADC data into temperature
*/
*Temp = XSysMon_RawToTemperature(TempData);
t = (float) XSysMon_RawToTemperature(TempData);
vint = (float) XSysMon_RawToVoltage(VccintData);
vaux = (float) XSysMon_RawToVoltage(VccauxData);
whole1 = t;
thousandths1 = (t - whole1) * 1000;
whole2 = vint;
thousandths2 = (vint - whole2) * 1000;
whole3 = vaux;
thousandths3 = (vaux - whole3) * 1000;
//xil_printf("Temperature: 0x%x, Vccint: 0x%x Vccaux: 0x%x [Exit: press any key]\r\n",
// TempData, VccintData, VccauxData);
printf("Temperature: %d.%3dC, Vccint: %d.%3dV Vccaux: %d.%3dV\r\n",
whole1, thousandths1, whole2, thousandths2, whole3, thousandths3);
for(j=0; j<10000;j++); // some delay
//if(!XUartNs550_IsReceiveData(STDIN_BASEADDRESS))
//{
// continue;
//}
//else
//{
// XUartNs550_ReadReg(STDIN_BASEADDRESS, XUN_RBR_OFFSET);
// return 0;
//}
i++;
}
#if 0
/*
* Set up Alarm threshold registers for the on-chip temperature and
* VCCAUX High limit and lower limit so that the alarms DONOT occur.
*/
XSysMon_SetAlarmThreshold(SysMonInstPtr, XSM_ATR_TEMP_UPPER, 0xFFFF);
XSysMon_SetAlarmThreshold(SysMonInstPtr, XSM_ATR_TEMP_LOWER, 0xFFFF);
XSysMon_SetAlarmThreshold(SysMonInstPtr, XSM_ATR_VCCAUX_UPPER, 0xFFFF);
XSysMon_SetAlarmThreshold(SysMonInstPtr, XSM_ATR_VCCAUX_LOWER, 0x0);
XSysMon_SetAlarmThreshold(SysMonInstPtr, XSM_ATR_VCCINT_UPPER, 0xFFFF);
XSysMon_SetAlarmThreshold(SysMonInstPtr, XSM_ATR_VCCINT_LOWER, 0x0);
/*
* Setup the interrupt system.
*/
Status = SysMonSetupInterruptSystem(IntcInstancePtr,
SysMonInstPtr,
SysMonIntrId);
if (Status != XST_SUCCESS) {
return XST_FAILURE;
}
#endif
/*
* Clear any bits set in the Interrupt Status Register.
*/
IntrStatus = XSysMon_IntrGetStatus(SysMonInstPtr);
XSysMon_IntrClear(SysMonInstPtr, IntrStatus);
#if 0
/*
* Enable Alarm 0 interrupt for on-chip temperature and Alarm 2
* interrupt for on-chip VCCAUX.
*/
XSysMon_IntrEnable(SysMonInstPtr,
XSM_IPIXR_TEMP_MASK |
XSM_IPIXR_VCCAUX_MASK);
/*
* Enable global interrupt of System Monitor.
*/
XSysMon_IntrGlobalEnable(SysMonInstPtr);
/*
* Set up Alarm threshold registers for
* On-chip Temperature High limit
* On-chip Temperature Low limit
* VCCAUX High limit
* VCCAUX Low limit
*/
XSysMon_SetAlarmThreshold(SysMonInstPtr, XSM_ATR_TEMP_UPPER,
TempData - 0x007F);
XSysMon_SetAlarmThreshold(SysMonInstPtr, XSM_ATR_TEMP_LOWER,
TempData - 0x007F);
XSysMon_SetAlarmThreshold(SysMonInstPtr, XSM_ATR_VCCAUX_UPPER,
VccauxData - 0x007F);
XSysMon_SetAlarmThreshold(SysMonInstPtr, XSM_ATR_VCCAUX_LOWER,
VccauxData + 0x007F);
/*
* Enable Alarm 0 for on-chip temperature and Alarm 2 for on-chip
* VCCAUX in the Configuration Register 1.
*/
XSysMon_SetAlarmEnables(SysMonInstPtr, (XSM_CFR1_ALM_VCCAUX_MASK |
XSM_CFR1_ALM_TEMP_MASK));
/*
* Wait until an Alarm 0 or Alarm 2 interrupt occurs.
*/
while (1) {
if (TemperatureIntr == TRUE) {
/*
* Alarm 0 - Temperature alarm interrupt has occurred.
* The required processing should be put here.
*/
break;
}
if (VccauxIntr == TRUE) {
/*
* Alarm 2 - VCCAUX alarm interrupt has occurred.
* The required processing should be put here.
*/
break;
}
}
#endif
/*
* Disable global interrupt of System Monitor.
*/
XSysMon_IntrGlobalDisable(SysMonInstPtr);
return XST_SUCCESS;
}
/**
*
* This function runs a test on the System Monitor/ADC device using the
* driver APIs.
*
* The function does the following tasks:
* - Initiate the System Monitor/ADC device driver instance
* - Run self-test on the device
* - Reset the device
* - Set up alarms for on-chip temperature and VCCAUX
* - Set up sequence registers to continuously monitor on-chip temperature
* and VCCAUX
* - Setup interrupt system
* - Enable interrupts
* - Set up configuration registers to start the sequence
* - Wait until temperature alarm interrupt or VCCAUX alarm interrupt
* occurs
*
* @param IntcInstancePtr is a pointer to the Interrupt Controller
* driver Instance.
* @param SysMonInstPtr is a pointer to the XSysMon driver Instance.
* @param SysMonDeviceId is the XPAR_<SYSMON_ADC_instance>_DEVICE_ID value
* from xparameters.h.
* @param SysMonIntrId is
* XPAR_<INTC_instance>_<SYSMON_ADC_instance>_VEC_ID value from
* xparameters.h
* @param Temp is an output parameter, it is a pointer through which the
* current temperature value is returned to the main function.
*
* @return
* - XST_SUCCESS if the example has completed successfully.
* - XST_FAILURE if the example has failed.
*
* @note This function may never return if no interrupt occurs.
*
****************************************************************************/
int SysMonIntrExample2(XSysMon* SysMonInstPtr,
u16 SysMonDeviceId, u16 SysMonIntrId, char *adcData, int printable)
{
int Status;
u32 TempData;
u32 VccauxData;
u32 VccintData;
u32 IntrStatus;
int j;
unsigned int whole1, thousandths1;
unsigned int whole2, thousandths2;
unsigned int whole3, thousandths3;
/*
* Initialize the SysMon driver.
*/
if(sysmon_init==0)
{
//xil_printf("XSysMon intr example\r\n");
SysMonConfigPtr = XSysMon_LookupConfig(SysMonDeviceId);
if (SysMonConfigPtr == NULL) {
return XST_FAILURE;
}
//xil_printf("XSysMon_CfgInitialize\r\n");
XSysMon_CfgInitialize(SysMonInstPtr, SysMonConfigPtr, SysMonConfigPtr->BaseAddress);
/*
* Self Test the System Monitor/ADC device.
*/
//xil_printf("XSysMon_SelfTest\r\n");
Status = XSysMon_SelfTest(SysMonInstPtr);
if (Status != XST_SUCCESS) {
xil_printf("XSysMon_SelfTest failed\r\n");
return XST_FAILURE;
}
sysmon_init = 1;
}
/*
* Disable the Channel Sequencer before configuring the Sequence
* registers.
*/
XSysMon_SetSequencerMode(SysMonInstPtr, XSM_SEQ_MODE_SAFE);
/*
* Setup the Averaging to be done for the channels in the
* Configuration 0 register as 16 samples:
*/
XSysMon_SetAvg(SysMonInstPtr, XSM_AVG_16_SAMPLES);
/*
* Enable the averaging on the following channels in the Sequencer
* registers:
* - On-chip Temperature
* - On-chip VCCAUX supply sensor
* - 1st Auxiliary Channel
* - 16th Auxiliary Channel
*/
Status = XSysMon_SetSeqAvgEnables(SysMonInstPtr, XSM_SEQ_CH_TEMP |
/* XSM_SEQ_CH_AUX00 | */
/* XSM_SEQ_CH_AUX15 | */
XSM_SEQ_CH_VCCINT |
XSM_SEQ_CH_VCCAUX );
if (Status != XST_SUCCESS) {
return XST_FAILURE;
}
/*
* Enable the following channels in the Sequencer registers:
* - On-chip Temperature
* - On-chip VCCAUX supply sensor
* - 1st Auxiliary Channel
* - 16th Auxiliary Channel
*/
Status = XSysMon_SetSeqChEnables(SysMonInstPtr, XSM_SEQ_CH_TEMP |
/* XSM_SEQ_CH_AUX00 | */
/* XSM_SEQ_CH_AUX15 | */
XSM_SEQ_CH_VCCINT |
XSM_SEQ_CH_VCCAUX );
if (Status != XST_SUCCESS) {
return XST_FAILURE;
}
/*
* Set the ADCCLK frequency equal to 1/32 of System clock for the System
* Monitor/ADC in the Configuration Register 2.
*/
XSysMon_SetAdcClkDivisor(SysMonInstPtr, 32);
/*
* Enable the Channel Sequencer in continuous sequencer cycling mode.
*/
XSysMon_SetSequencerMode(SysMonInstPtr, XSM_SEQ_MODE_CONTINPASS);
/*
* Disable all the alarms in the Configuration Register 1.
*/
XSysMon_SetAlarmEnables(SysMonInstPtr, 0x0);
/*
* Wait till the End of Sequence occurs
*/
XSysMon_GetStatus(SysMonInstPtr); /* Clear the old status */
do
{
if((XSysMon_GetStatus(SysMonInstPtr) & XSM_SR_EOS_MASK) ==
XSM_SR_EOS_MASK)
break;
} while(1);
/*
* Read the ADC converted Data from the data registers for on-chip
* temperature and on-chip VCCAUX voltage.
*/
TempData = XSysMon_GetAdcData(SysMonInstPtr, XSM_CH_TEMP);
VccauxData = XSysMon_GetAdcData(SysMonInstPtr, XSM_CH_VCCAUX);
VccintData = XSysMon_GetAdcData(SysMonInstPtr, XSM_CH_VCCINT);
/*
* Convert the ADC data into temperature
*/
//*Temp = XSysMon_RawToTemperature(TempData);
t = (float) XSysMon_RawToTemperature(TempData);
vint = (float) XSysMon_RawToVoltage(VccintData);
vaux = (float) XSysMon_RawToVoltage(VccauxData);
whole1 = t;
thousandths1 = (t - whole1) * 1000;
whole2 = vint;
thousandths2 = (vint - whole2) * 1000;
whole3 = vaux;
thousandths3 = (vaux - whole3) * 1000;
//xil_printf("Temperature: 0x%x, Vccint: 0x%x Vccaux: 0x%x [Exit: press any key]\r\n",
// TempData, VccintData, VccauxData);
if(printable==1)
{
// send complete string with units
sprintf(adcData, "Temperature:%d.%-3dC, Vccint:%d.%-3dV, Vccaux: %d.%-3dV",
whole1, thousandths1, whole2, thousandths2, whole3, thousandths3);
}
else
{
// send ONLY the numbers (used for graph plot by the webserver
sprintf(adcData, "%d.%-d, %d.%-d, %d.%-d",
whole1, thousandths1, whole2, thousandths2, whole3, thousandths3);
}
//printf("Temperature: %d.%3dC, Vccint: %d.%3dV Vccaux: %d.%3dV\r\n",
// whole1, thousandths1, whole2, thousandths2, whole3, thousandths3);
for(j=0; j<10000;j++); // some delay
//if(!XUartNs550_IsReceiveData(STDIN_BASEADDRESS))
//{
// continue;
//}
//else
//{
// XUartNs550_ReadReg(STDIN_BASEADDRESS, XUN_RBR_OFFSET);
// return 0;
//}
/*
* Clear any bits set in the Interrupt Status Register.
*/
IntrStatus = XSysMon_IntrGetStatus(SysMonInstPtr);
XSysMon_IntrClear(SysMonInstPtr, IntrStatus);
/*
* Disable global interrupt of System Monitor.
*/
XSysMon_IntrGlobalDisable(SysMonInstPtr);
return XST_SUCCESS;
}
int main(void)
{
u32 cmd, data_channels, delay;
u32 xStatus;
u8 iop_pins[19];
int i, log_capacity;
u32 xadc_raw_value;
float xadc_voltage;
// Initialize PMOD and timers
arduino_init(0,0,0,0);
// SysMon Initialize
SysMonConfigPtr = XSysMon_LookupConfig(SYSMON_DEVICE_ID);
if(SysMonConfigPtr == NULL)
xil_printf("SysMon LookupConfig failed.\n\r");
xStatus = XSysMon_CfgInitialize(SysMonInstPtr, SysMonConfigPtr,
SysMonConfigPtr->BaseAddress);
if(XST_SUCCESS != xStatus)
xil_printf("SysMon CfgInitialize failed\r\n");
// Clear the old status
XSysMon_GetStatus(SysMonInstPtr);
// Initialize the default switch
config_arduino_switch(A_GPIO, A_GPIO, A_GPIO, A_GPIO, A_GPIO, A_GPIO,
D_GPIO, D_GPIO, D_GPIO, D_GPIO, D_GPIO,
D_GPIO, D_GPIO, D_GPIO, D_GPIO,
D_GPIO, D_GPIO, D_GPIO, D_GPIO);
while(1){
// wait and store valid command
while((MAILBOX_CMD_ADDR & 0x1)==0);
cmd = (MAILBOX_CMD_ADDR & 0xF);
switch(cmd){
case CONFIG_IOP_SWITCH:
// Assign default pin configurations
iop_pins[0] = MAILBOX_DATA(0);
iop_pins[1] = MAILBOX_DATA(1);
iop_pins[2] = MAILBOX_DATA(2);
iop_pins[3] = MAILBOX_DATA(3);
iop_pins[4] = MAILBOX_DATA(4);
iop_pins[5] = MAILBOX_DATA(5);
iop_pins[6] = D_GPIO;
iop_pins[7] = D_GPIO;
iop_pins[8] = D_GPIO;
iop_pins[9] = D_GPIO;
iop_pins[10] = D_GPIO;
iop_pins[11] = D_GPIO;
iop_pins[12] = D_GPIO;
iop_pins[13] = D_GPIO;
iop_pins[14] = D_GPIO;
iop_pins[15] = D_GPIO;
iop_pins[16] = D_GPIO;
iop_pins[17] = D_GPIO;
iop_pins[18] = D_GPIO;
config_arduino_switch(iop_pins[0], iop_pins[1], iop_pins[2],
iop_pins[3], iop_pins[4], iop_pins[5],
iop_pins[6], iop_pins[7],
iop_pins[8], iop_pins[9],
iop_pins[10], iop_pins[11],
iop_pins[12], iop_pins[13],
iop_pins[14], iop_pins[15],
iop_pins[16], iop_pins[17],
iop_pins[18]);
MAILBOX_CMD_ADDR = 0x0;
break;
case GET_RAW_DATA:
i=0;
// Wait for the conversion complete
while ((XSysMon_GetStatus(SysMonInstPtr) &
XSM_SR_EOS_MASK) != XSM_SR_EOS_MASK);
data_channels = MAILBOX_CMD_ADDR >> 8;
if(data_channels & 0x1)
MAILBOX_DATA(i++) = XSysMon_GetAdcData(SysMonInstPtr,
XSM_CH_AUX_MIN+1);
if(data_channels & 0x2)
MAILBOX_DATA(i++) = XSysMon_GetAdcData(SysMonInstPtr,
XSM_CH_AUX_MIN+9);
if(data_channels & 0x4)
MAILBOX_DATA(i++) = XSysMon_GetAdcData(SysMonInstPtr,
XSM_CH_AUX_MIN+6);
if(data_channels & 0x8)
MAILBOX_DATA(i++) = XSysMon_GetAdcData(SysMonInstPtr,
XSM_CH_AUX_MIN+15);
if(data_channels & 0x10)
MAILBOX_DATA(i++) = XSysMon_GetAdcData(SysMonInstPtr,
XSM_CH_AUX_MIN+5);
if(data_channels & 0x20)
MAILBOX_DATA(i++) = XSysMon_GetAdcData(SysMonInstPtr,
XSM_CH_AUX_MIN+13);
MAILBOX_CMD_ADDR = 0x0;
break;
case GET_VOLTAGE:
i=0;
// Wait for the conversion complete
while ((XSysMon_GetStatus(SysMonInstPtr) &
XSM_SR_EOS_MASK) != XSM_SR_EOS_MASK);
data_channels = MAILBOX_CMD_ADDR >> 8;
if(data_channels & 0x1)
MAILBOX_DATA_FLOAT(i++) = (float)(XSysMon_GetAdcData(
SysMonInstPtr,XSM_CH_AUX_MIN+1)*V_REF/65536);
if(data_channels & 0x2)
MAILBOX_DATA_FLOAT(i++) = (float)(XSysMon_GetAdcData(
SysMonInstPtr,XSM_CH_AUX_MIN+9)*V_REF/65536);
if(data_channels & 0x4)
MAILBOX_DATA_FLOAT(i++) = (float)(XSysMon_GetAdcData(
SysMonInstPtr,XSM_CH_AUX_MIN+6)*V_REF/65536);
if(data_channels & 0x8)
MAILBOX_DATA_FLOAT(i++) = (float)(XSysMon_GetAdcData(
SysMonInstPtr,XSM_CH_AUX_MIN+15)*V_REF/65536);
if(data_channels & 0x10)
MAILBOX_DATA_FLOAT(i++) = (float)(XSysMon_GetAdcData(
SysMonInstPtr,XSM_CH_AUX_MIN+5)*V_REF/65536);
if(data_channels & 0x20)
MAILBOX_DATA_FLOAT(i++) = (float)(XSysMon_GetAdcData(
SysMonInstPtr,XSM_CH_AUX_MIN+13)*V_REF/65536);
MAILBOX_CMD_ADDR = 0x0;
break;
case READ_AND_LOG_RAW:
// initialize logging variables, reset cmd
delay = MAILBOX_DATA(1);
// get channels to be sampled
data_channels = MAILBOX_CMD_ADDR >> 8;
// allocate 1000 samples per channel
log_capacity = 4000 / LOG_INT_SIZE *
count_set_bits(data_channels);
cb_init(&arduino_log, LOG_BASE_ADDRESS,
log_capacity, LOG_INT_SIZE);
while(MAILBOX_CMD_ADDR != RESET_ANALOG){
// wait for sample conversion
while ((XSysMon_GetStatus(SysMonInstPtr) &
XSM_SR_EOS_MASK) != XSM_SR_EOS_MASK);
if(data_channels & 0x1) {
xadc_raw_value = XSysMon_GetAdcData(SysMonInstPtr,
XSM_CH_AUX_MIN+1);
cb_push_back(&arduino_log, &xadc_raw_value);
}
if(data_channels & 0x2) {
xadc_raw_value = XSysMon_GetAdcData(SysMonInstPtr,
XSM_CH_AUX_MIN+9);
cb_push_back(&arduino_log, &xadc_raw_value);
}
if(data_channels & 0x4) {
xadc_raw_value = XSysMon_GetAdcData(SysMonInstPtr,
XSM_CH_AUX_MIN+6);
cb_push_back(&arduino_log, &xadc_raw_value);
}
if(data_channels & 0x8) {
xadc_raw_value = XSysMon_GetAdcData(SysMonInstPtr,
XSM_CH_AUX_MIN+15);
cb_push_back(&arduino_log, &xadc_raw_value);
}
if(data_channels & 0x10) {
xadc_raw_value = XSysMon_GetAdcData(SysMonInstPtr,
XSM_CH_AUX_MIN+5);
cb_push_back(&arduino_log, &xadc_raw_value);
}
if(data_channels & 0x20) {
xadc_raw_value = XSysMon_GetAdcData(SysMonInstPtr,
XSM_CH_AUX_MIN+13);
cb_push_back(&arduino_log, &xadc_raw_value);
}
delay_ms(delay);
}
MAILBOX_CMD_ADDR = 0x0;
break;
case READ_AND_LOG_FLOAT:
// initialize logging variables, reset cmd
delay = MAILBOX_DATA(1);
// get channels to be sampled
data_channels = MAILBOX_CMD_ADDR >> 8;
// allocate 1000 samples per channel
log_capacity = 4000 / LOG_FLOAT_SIZE *
count_set_bits(data_channels);
cb_init(&arduino_log, LOG_BASE_ADDRESS,
log_capacity, LOG_FLOAT_SIZE);
while(MAILBOX_CMD_ADDR != RESET_ANALOG){
// wait for sample conversion
while ((XSysMon_GetStatus(SysMonInstPtr) &
XSM_SR_EOS_MASK) != XSM_SR_EOS_MASK);
if(data_channels & 0x1) {
xadc_voltage = (float)(XSysMon_GetAdcData(
SysMonInstPtr,XSM_CH_AUX_MIN+1)*V_REF/65536);
cb_push_back_float(&arduino_log, &xadc_voltage);
}
if(data_channels & 0x2) {
xadc_voltage = (float)(XSysMon_GetAdcData(
SysMonInstPtr,XSM_CH_AUX_MIN+9)*V_REF/65536);
cb_push_back_float(&arduino_log, &xadc_voltage);
}
if(data_channels & 0x4) {
xadc_voltage = (float)(XSysMon_GetAdcData(
SysMonInstPtr,XSM_CH_AUX_MIN+6)*V_REF/65536);
cb_push_back_float(&arduino_log, &xadc_voltage);
}
if(data_channels & 0x8) {
xadc_voltage = (float)(XSysMon_GetAdcData(
SysMonInstPtr,XSM_CH_AUX_MIN+15)*V_REF/65536);
cb_push_back_float(&arduino_log, &xadc_voltage);
}
if(data_channels & 0x10) {
xadc_voltage = (float)(XSysMon_GetAdcData(
SysMonInstPtr,XSM_CH_AUX_MIN+5)*V_REF/65536);
cb_push_back_float(&arduino_log, &xadc_voltage);
}
if(data_channels & 0x20) {
xadc_voltage = (float)(XSysMon_GetAdcData(
SysMonInstPtr,XSM_CH_AUX_MIN+13)*V_REF/65536);
cb_push_back_float(&arduino_log, &xadc_voltage);
}
delay_ms(delay);
}
MAILBOX_CMD_ADDR = 0x0;
break;
case RESET_ANALOG:
// SysMon Initialize
SysMonConfigPtr = XSysMon_LookupConfig(SYSMON_DEVICE_ID);
if(SysMonConfigPtr == NULL)
xil_printf("SysMon LookupConfig failed.\n\r");
xStatus = XSysMon_CfgInitialize(SysMonInstPtr,
SysMonConfigPtr, SysMonConfigPtr->BaseAddress);
if(XST_SUCCESS != xStatus)
xil_printf("SysMon CfgInitialize failed.\r\n");
// Clear the old status
XSysMon_GetStatus(SysMonInstPtr);
MAILBOX_CMD_ADDR = 0x0;
break;
default:
MAILBOX_CMD_ADDR = 0x0;
break;
}
}
return 0;
}
/**
*
* This function runs a test on the System Monitor/ADC device using the
* driver APIs.
* This function does the following tasks:
* - Initiate the System Monitor device driver instance
* - Run self-test on the device
* - Setup the sequence registers to continuously monitor on-chip
* temperature, VCCINT and VCCAUX
* - Setup configuration registers to start the sequence
* - Read the latest on-chip temperature, VCCINT and VCCAUX
*
* @param SysMonDeviceId is the XPAR_<SYSMON_ADC_instance>_DEVICE_ID value
* from xparameters.h.
*
* @return
* - XST_SUCCESS if the example has completed successfully.
* - XST_FAILURE if the example has failed.
*
* @note None
*
****************************************************************************/
int SysMonPolledPrintfExample(u16 SysMonDeviceId)
{
int Status;
XSysMon_Config *ConfigPtr;
u32 TempRawData;
u32 VccAuxRawData;
u32 VccIntRawData;
float TempData;
float VccAuxData;
float VccIntData;
float MaxData;
float MinData;
XSysMon *SysMonInstPtr = &SysMonInst;
printf("\r\nEntering the SysMon Polled Example. \r\n");
/*
* Initialize the SysMon driver.
*/
ConfigPtr = XSysMon_LookupConfig(SysMonDeviceId);
if (ConfigPtr == NULL) {
return XST_FAILURE;
}
XSysMon_CfgInitialize(SysMonInstPtr, ConfigPtr,
ConfigPtr->BaseAddress);
/*
* Self Test the System Monitor/ADC device
*/
Status = XSysMon_SelfTest(SysMonInstPtr);
if (Status != XST_SUCCESS) {
return XST_FAILURE;
}
/*
* Disable the Channel Sequencer before configuring the Sequence
* registers.
*/
XSysMon_SetSequencerMode(SysMonInstPtr, XSM_SEQ_MODE_SAFE);
/*
* Disable all the alarms in the Configuration Register 1.
*/
XSysMon_SetAlarmEnables(SysMonInstPtr, 0x0);
/*
* Setup the Averaging to be done for the channels in the
* Configuration 0 register as 16 samples:
*/
XSysMon_SetAvg(SysMonInstPtr, XSM_AVG_16_SAMPLES);
/*
* Setup the Sequence register for 1st Auxiliary channel
* Setting is:
* - Add acquisition time by 6 ADCCLK cycles.
* - Bipolar Mode
*
* Setup the Sequence register for 16th Auxiliary channel
* Setting is:
* - Add acquisition time by 6 ADCCLK cycles.
* - Unipolar Mode
*/
Status = XSysMon_SetSeqInputMode(SysMonInstPtr, XSM_SEQ_CH_AUX00);
if (Status != XST_SUCCESS) {
return XST_FAILURE;
}
Status = XSysMon_SetSeqAcqTime(SysMonInstPtr, XSM_SEQ_CH_AUX15 |
XSM_SEQ_CH_AUX00);
if (Status != XST_SUCCESS) {
return XST_FAILURE;
}
/*
* Enable the averaging on the following channels in the Sequencer
* registers:
* - On-chip Temperature, VCCINT/VCCAUX supply sensors
* - 1st/16th Auxiliary Channels
* - Calibration Channel
*/
Status = XSysMon_SetSeqAvgEnables(SysMonInstPtr, XSM_SEQ_CH_TEMP |
XSM_SEQ_CH_VCCINT |
XSM_SEQ_CH_VCCAUX |
XSM_SEQ_CH_AUX00 |
XSM_SEQ_CH_AUX15 |
XSM_SEQ_CH_CALIB);
if (Status != XST_SUCCESS) {
return XST_FAILURE;
}
/*
* Enable the following channels in the Sequencer registers:
* - On-chip Temperature, VCCINT/VCCAUX supply sensors
* - 1st/16th Auxiliary Channel
* - Calibration Channel
*/
Status = XSysMon_SetSeqChEnables(SysMonInstPtr, XSM_SEQ_CH_TEMP |
XSM_SEQ_CH_VCCINT |
XSM_SEQ_CH_VCCAUX |
XSM_SEQ_CH_AUX00 |
XSM_SEQ_CH_AUX15 |
XSM_SEQ_CH_CALIB);
if (Status != XST_SUCCESS) {
return XST_FAILURE;
}
/*
* Set the ADCCLK frequency equal to 1/32 of System clock for the System
* Monitor/ADC in the Configuration Register 2.
*/
XSysMon_SetAdcClkDivisor(SysMonInstPtr, 32);
/*
* Set the Calibration enables.
*/
XSysMon_SetCalibEnables(SysMonInstPtr,
XSM_CFR1_CAL_PS_GAIN_OFFSET_MASK |
XSM_CFR1_CAL_ADC_GAIN_OFFSET_MASK);
/*
* Enable the Channel Sequencer in continuous sequencer cycling mode.
*/
XSysMon_SetSequencerMode(SysMonInstPtr, XSM_SEQ_MODE_CONTINPASS);
/*
* Wait till the End of Sequence occurs
*/
XSysMon_GetStatus(SysMonInstPtr); /* Clear the old status */
while ((XSysMon_GetStatus(SysMonInstPtr) & XSM_SR_EOS_MASK) !=
XSM_SR_EOS_MASK);
/*
* Read the on-chip Temperature Data (Current/Maximum/Minimum)
* from the ADC data registers.
*/
TempRawData = XSysMon_GetAdcData(SysMonInstPtr, XSM_CH_TEMP);
TempData = XSysMon_RawToTemperature(TempRawData);
printf("\r\nThe Current Temperature is %0d.%03d Centigrades.\r\n",
(int)(TempData), SysMonFractionToInt(TempData));
TempRawData = XSysMon_GetMinMaxMeasurement(SysMonInstPtr, XSM_MAX_TEMP);
MaxData = XSysMon_RawToTemperature(TempRawData);
printf("The Maximum Temperature is %0d.%03d Centigrades. \r\n",
(int)(MaxData), SysMonFractionToInt(MaxData));
TempRawData = XSysMon_GetMinMaxMeasurement(SysMonInstPtr, XSM_MIN_TEMP);
MinData = XSysMon_RawToTemperature(TempRawData);
printf("The Minimum Temperature is %0d.%03d Centigrades. \r\n",
(int)(MinData), SysMonFractionToInt(MinData));
/*
* Read the VccInt Votage Data (Current/Maximum/Minimum) from the
* ADC data registers.
*/
VccIntRawData = XSysMon_GetAdcData(SysMonInstPtr, XSM_CH_VCCINT);
VccIntData = XSysMon_RawToVoltage(VccIntRawData);
printf("\r\nThe Current VCCINT is %0d.%03d Volts. \r\n",
(int)(VccIntData), SysMonFractionToInt(VccIntData));
VccIntRawData = XSysMon_GetMinMaxMeasurement(SysMonInstPtr,
XSM_MAX_VCCINT);
MaxData = XSysMon_RawToVoltage(VccIntRawData);
printf("The Maximum VCCINT is %0d.%03d Volts. \r\n",
(int)(MaxData), SysMonFractionToInt(MaxData));
VccIntRawData = XSysMon_GetMinMaxMeasurement(SysMonInstPtr,
XSM_MIN_VCCINT);
MinData = XSysMon_RawToVoltage(VccIntRawData);
printf("The Minimum VCCINT is %0d.%03d Volts. \r\n",
(int)(MinData), SysMonFractionToInt(MinData));
/*
* Read the VccAux Votage Data (Current/Maximum/Minimum) from the
* ADC data registers.
*/
VccAuxRawData = XSysMon_GetAdcData(SysMonInstPtr, XSM_CH_VCCAUX);
VccAuxData = XSysMon_RawToVoltage(VccAuxRawData);
printf("\r\nThe Current VCCAUX is %0d.%03d Volts. \r\n",
(int)(VccAuxData), SysMonFractionToInt(VccAuxData));
VccAuxRawData = XSysMon_GetMinMaxMeasurement(SysMonInstPtr,
XSM_MAX_VCCAUX);
MaxData = XSysMon_RawToVoltage(VccAuxRawData);
printf("The Maximum VCCAUX is %0d.%03d Volts. \r\n",
(int)(MaxData), SysMonFractionToInt(MaxData));
VccAuxRawData = XSysMon_GetMinMaxMeasurement(SysMonInstPtr,
XSM_MIN_VCCAUX);
MinData = XSysMon_RawToVoltage(VccAuxRawData);
printf("The Minimum VCCAUX is %0d.%03d Volts. \r\n\r\n",
(int)(MinData), SysMonFractionToInt(MinData));
printf("Exiting the SysMon Polled Example. \r\n");
return XST_SUCCESS;
}
/***************************************************************************
* Looks up the current config and initializes XADC_WIZ
*
* @ Channel: Chooses channel for single channel mode. Options are Channel 6, Channel 7,
* Channel 14 and Channel 15.
*
* @ SequencerMode: Choose between SINGLE_CHANNEL_MODE (= XSM_SEQ_MODE_SINGCHAN) for single channel mode
* or CONTINUOUS_SAMPLING_MODE(= XSM_SEQ_MODE_CONTINPASS) for continuous sequencing mode.
*
* Always in Differential mode
* Always in continuous mode
* Always slow AcQCycles ( for sequence mode of operations adjust XSysMon_SetSeqAcqTime(&SysMon , SEQ_CHANNELS) to
* XSysMon_SetSeqAcqTime(&SysMon , ~SEQ_CHANNELS) )
*
***************************************************************************/
void init_XADC_WIZ(char channel, u8 SequencerMode)
{
int Status;
int ParameterStatus;
int SequenceStatus;
int InputStatus;
int AcqStatus;
int IncreaseAcqCycles = FALSE;
int IsEventMode = FALSE;
int IsDifferentialMode = TRUE;
u8 Divisor = 0;
XSysMon_Config *Config;
Config = XSysMon_LookupConfig(XPAR_XADC_WIZ_0_DEVICE_ID);
if (NULL == Config) {
//return XST_FAILURE;
}
Status = XSysMon_CfgInitialize(&SysMon,Config ,Config->BaseAddress);
if (Status != XST_SUCCESS) {
xil_printf("XADC_WIZ initialization FAILED!\n \r");
//return XST_FAILURE;
}
else {
xil_printf("XADC_WIZ initialization SUCCESS!\n \r");
}
/* NO averaging*/
XSysMon_SetAvg(&SysMon, XSM_AVG_0_SAMPLES);
/* Calibrate ADC gain and offset + Power Supply gain and offset*/
XSysMon_SetCalibEnables(&SysMon, XSM_CFR1_CAL_ADC_GAIN_OFFSET_MASK | XSM_CFR1_CAL_PS_GAIN_OFFSET_MASK);
/* Sets the channel seqence mode:
* - Default safe mode (XSM_SEQ_MODE_SAFE)
* - One pass through sequence (XSM_SEQ_MODE_ONEPASS)
* - Continuous channel sequencing (XSM_SEQ_MODE_CONTINPASS)
* - Single Channel/Sequencer off (XSM_SEQ_MODE_SINGCHAN)
* - Simulataneous sampling mode (XSM_SEQ_MODE_SIMUL)
* - Independent mode (XSM_SEQ_MODE_INDEPENDENT)
*
* NOTE: We will only use single channel mode and continious channel sequencing mode!!!
*/
if(SequencerMode = XSM_SEQ_MODE_SINGCHAN)
{
XSysMon_SetSequencerMode(&SysMon,XSM_SEQ_MODE_SINGCHAN);
/* Sets the parameters for the single channel mode
* int ParameterStatus; => Return value, =1 when failed
* int IncreaseAcqCycles = FALSE; => TRUE: increased to 10 ADCCLK cycles | FALSE: default 4 ADCCLK cycles
* int IsEventMode = FALSE; => TRUE: event driven sampling mode | FALSE: continious sampling mode
* int IsDifferentialMode = TRUE; => TRUE: differential mode | FALSE: unipolar mode
*/
ParameterStatus = XSysMon_SetSingleChParams(&SysMon,(XSM_CH_AUX_MIN + (channel -1)),
IncreaseAcqCycles, IsEventMode, IsDifferentialMode);
if (ParameterStatus != XST_SUCCESS) {
xil_printf("Setting SingleChannelParameters FAILED!\n \r");
}
}
else if(SequencerMode = XSM_SEQ_MODE_CONTINPASS)
{
XSysMon_SetSequencerMode(&SysMon,XSM_SEQ_MODE_SAFE); /* Settings need to be applied in safe mode*/
XSysMon_SetSequencerEvent(&SysMon, IsEventMode); /* IsEventmode = FALSE => continious sampling!*/
XSysMon_SetAdcClkDivisor(&SysMon, Divisor); /* Divisor sets the clockdevision for the ADC sampling*/
SequenceStatus= XSysMon_SetSeqChEnables(&SysMon,SEQ_CHANNELS); /* Selects channels to sequence*/
if (SequenceStatus != XST_SUCCESS) {
xil_printf("Enabling Sequence Channels FAILED!\n \r");
}
InputStatus = XSysMon_SetSeqInputMode(&SysMon, SEQ_CHANNELS); /* Sets the channels to differential mode */
if (InputStatus != XST_SUCCESS) {
xil_printf("Setting Input Mode FAILED!\n \r");
}
AcqStatus = XSysMon_SetSeqAcqTime(&SysMon , SEQ_CHANNELS); /* If function is enabled: Acquisition cycles will be extended to 10 ADCCLK cycles*/
if (AcqStatus != XST_SUCCESS) {
xil_printf("Setting AcqTime FAILED!\n \r");
}
XSysMon_SetSequencerMode(&SysMon,XSM_SEQ_MODE_CONTINPASS); /* Continuous sampling mode enabled */
}
}
