/*! \brief Detect Board Revision
*
* @retval Version Number of Board
*/
uint8_t BOARD_Detect_Revision(void)
{
ADC_Result result;
uint16_t revision_value;
uint8_t i;
PGA_SetChannel(SPI_DEVICE_AMP_V_I_DCBUS, CHANNEL1);
ADC_Enable(TSB_ADB);
ADC_SetClk(TSB_ADB, ADC_HOLD_FIX, ADC_FC_DIVIDE_LEVEL_2);
ADC_SetSWTrg(TSB_ADB, ADC_REG2, TRG_ENABLE(ADC_REG2));
ADC_Start(TSB_ADB, ADC_TRG_SW);
while (ADC_GetConvertState(TSB_ADB, ADC_TRG_SW) == BUSY);
result=ADC_GetConvertResult(TSB_ADB, ADC_REG2);
ADC_Disable(TSB_ADB);
PGA_SetChannel(SPI_DEVICE_AMP_V_I_DCBUS, CHANNEL0);
for (i=0;i<sizeof(revisions)/sizeof(revisions[0]);i++)
{
revision_value = result.Bit.ADResult*10/gaintable[ChannelValues[1].gain_current_measure];
if (abs((revisions[i][0]-revision_value)<100))
break;
}
return revisions[i][1];
}
void Example_ADC_ReadData(void)
{
/* 1. set ADC clock */
ADC_SetClk(TSB_ADB, ADC_HOLD_FIX, ADC_FC_DIVIDE_LEVEL_2);
/* 2. select trigger and AD channel, this time we use sofeware trigger, */
/* the VR1 is connected to ADC unit B channel 2, remember to input with macro TRG_ENABLE() */
ADC_SetSWTrg(TSB_ADB, ADC_REG0, TRG_ENABLE(ADC_AIN2));
/* 3. enable ADC module */
ADC_Enable(TSB_ADB);
/* 4. now start ADC */
ADC_Start(TSB_ADB, ADC_TRG_SW);
/* initialize LEDs on M374-SK board before display something */
LED_Init();
while (1U) {
/* check ADC module state */
adcState = ADC_GetConvertState(TSB_ADB, ADC_TRG_SW);
if (adcState == DONE) {
/* read ADC result when it is finished */
result = ADC_GetConvertResult(TSB_ADB, ADC_REG0);
/* get the real ADC result without other information */
/* "/16" is to limit the range of AD value */
myResult = result.Bit.ADResult / 16U;
/* software trigger, need to trigger it again */
ADC_Start(TSB_ADB, ADC_TRG_SW);
}
myDelay(myResult);
if(idx)
{
LED_Off(LEDs[idx-1]);
}
idx &= 0x03U;
myDelay(myResult);
LED_On(LEDs[idx]);
idx++;
}
}
/**
* @brief main function to run CAN demo
* @param None.
* @retval result to retun to system.
*/
void CAN_TestLoopBack(void)
{
CAN_GlobalState globalstate;
CAN_INTFactor intmask;
WorkState adc_state = BUSY;
ADC_ResultTypeDef adc_value;
CAN_BitTimingTypeDef bittiming =
{ BAUDRATE_PRESCALER, CAN_TIMING_TSEG1_7TQ, CAN_TIMING_TSEG2_4TQ, CAN_SINGLE_SAMPLING,
CAN_TIMING_SJW_1TQ
};
CAN_MsgTypeDef msgtx = { 0U };
CAN_MsgTypeDef msgrx = { 0U };
CAN_PortInit();
ADC_Init();
/* CAN bit timing setting */
CAN_ConfigBitTiming(&bittiming);
/* CAN Tx mailbox0 setting */
msgtx.MsgID = MSG_ID;
msgtx.MsgDataLen = 1U; /* data length: 1 byte */
CAN_SetMbxMsg(CAN_MBX_0, &msgtx);
CAN_SetMbxDirection(CAN_MBX_0, CAN_MBX_TX); /* mailbox0: Tx */
/* CAN Rx mailbox10 setting */
msgrx.MsgID = msgtx.MsgID; /* ID of mailbox10 = ID of mailbox0 */
CAN_SetMbxMsg(CAN_MBX_10, &msgrx);
CAN_SetMbxDirection(CAN_MBX_10, CAN_MBX_RX); /* mailbox10: Rx */
CAN_SetTxOrder(CAN_TX_ORDER_MBX_NUM); /* Tx order: by mailbox number */
globalstate.All = 0U;
/* Enter suspend mode */
CAN_SetMode(CAN_SUSPEND_MODE);
while (globalstate.Bit.SuspendModeAck == 0U) {
globalstate = CAN_GetGlobalState();
}
/* Set test loop back mode */
CAN_SetTestMode(CAN_TEST_LOOP_BACK_MODE, ENABLE);
/* Return normal mode */
CAN_SetMode(CAN_NORMAL_MODE);
while (globalstate.Bit.SuspendModeAck == 1U) {
globalstate = CAN_GetGlobalState();
}
/* Enable mailbox10 Rx interrupt */
intmask.MbxBit.Mbx10 = 1U;
CAN_SetINTMask(CAN_INT_MBX_MASK, &intmask);
NVIC_EnableIRQ(INTCANRX_IRQn);
/* Enable mailbox0 and 10 */
CAN_EnableMbx(CAN_MBX_0 | CAN_MBX_10);
/* ADC start to run */
ADC_Start();
while (1) {
adc_state = ADC_GetConvertState();
if (DONE == adc_state) { /* ADC convertion finished */
adc_state = BUSY;
adc_value = ADC_GetConvertResult(ADC_REG_08);
msgtx.MsgData[0] = (uint8_t) adc_value.ADCResultValue;
CAN_SetMbxMsg(CAN_MBX_0, &msgtx); /* Put the ADC result into mailbox0 */
CAN_SetTxReq(CAN_MBX_0, ENABLE); /* Start to send */
} else {
/* Do nothing */
}
delay(50000U);
}
}
