/**
* @brief Handle interrupt from ADC sequencer A
* @return Nothing
*/
void ADC0A_IRQHandler(void)
{
uint32_t i, pending;
uint32_t gdata_value, data_value, seq_ctrl_value, ch_offset;
/* Get pending interrupts */
pending = Chip_ADC_GetFlags(LPC_ADC);
/* Sequence A completion interrupt */
if (pending & ADC_FLAGS_SEQA_INT_MASK) {
seq_ctrl_value = Chip_ADC_GetSequencerCtrl(LPC_ADC, ADC_SEQA_IDX);
if ( seq_ctrl_value & ADC_SEQ_CTRL_MODE_EOS ) {
/* End of sequence, get raw sample data for channels 0-11 */
for (i = 0; i < BOARD_ADC_CH; i++) {
if ( seq_ctrl_value & (0x1<<i) ) {
if ( (data_value = Chip_ADC_GetDataReg(LPC_ADC, i)) & ADC_DR_DATAVALID ) {
ADC_Data_Buffer[i] = ADC_DR_RESULT(data_value);
channel_completion |= ( 0x1 << i );
}
}
}
}
else {
/* End of conversion, get raw sample data for channels 0-11 */
gdata_value = Chip_ADC_GetGlobalDataReg(LPC_ADC, ADC_SEQA_IDX);
if ( gdata_value & ADC_SEQ_GDAT_DATAVALID ) {
ch_offset = (gdata_value & ADC_SEQ_GDAT_CHAN_MASK) >> ADC_SEQ_GDAT_CHAN_BITPOS;
ADC_Data_Buffer[ch_offset] = ADC_DR_RESULT(gdata_value);
channel_completion |= (0x1<<ch_offset);
}
if ( channel_completion != (seq_ctrl_value & 0xFFF) ) {
/* Not all channels are completed. */
if ( (seq_ctrl_value & ADC_SEQ_CTRL_SINGLESTEP) && !(seq_ctrl_value & ADC_SEQ_CTRL_BURST) ) {
/* If SINGLE_STEP is set and BURST is not, this sequence needs to be restarted. */
Chip_ADC_StartSequencer(LPC_ADC, ADC_SEQA_IDX);
}
}
}
int main(void)
{
boardInit();
SysTick_Config(SystemCoreClock / TICKRATE_HZ);
dsPuts(&streamUart, strHello);
while (1)
{
promptProcess(&adcEvalPromptData, &streamUart);
/* Is a conversion sequence complete? */
if(sequenceComplete)
{
sequenceComplete = false;
/* Get raw sample data for channels 0-11 */
for (uint16_t i = 0; i < 12; i++) {
uint32_t rawSample = Chip_ADC_GetDataReg(LPC_ADC, i);
/* Show some ADC data */
if (rawSample & (ADC_DR_OVERRUN | ADC_SEQ_GDAT_DATAVALID))
{
printDecNzU16(&streamUart, i);
dsPuts(&streamUart, strIs);
printDecU16(&streamUart, ADC_DR_RESULT(rawSample));
dsPuts(&streamUart, strSep);
}
}
dsPuts(&streamUart, strCrLf);
}
}
return 0 ;
}
/**
* @brief main routine for ADC example
* @return Function should not exit
*/
int main(void)
{
uint32_t rawSample;
int j;
SystemCoreClockUpdate();
Board_Init();
DEBUGSTR("ADC Demo\r\n");
/* Setup ADC for 12-bit mode and normal power */
Chip_ADC_Init(LPC_ADC, 0);
/* Setup for maximum ADC clock rate */
Chip_ADC_SetClockRate(LPC_ADC, ADC_MAX_SAMPLE_RATE);
/* Setup sequencer A for ADC channel 1, EOS interrupt */
#if defined(BOARD_MCORE48_1125)
/* Setup a sequencer to do the following:
Perform ADC conversion of ADC channel 1 only
Trigger on low edge of PIO0_7 */
Chip_ADC_SetupSequencer(LPC_ADC, ADC_SEQA_IDX, (ADC_SEQ_CTRL_CHANSEL(1) |
ADC_SEQ_CTRL_MODE_EOS | ADC_SEQ_CTRL_HWTRIG_PIO0_7));
/* Select ADC_1 mux for PIO1_11 */
Chip_IOCON_PinMuxSet(LPC_IOCON, IOCON_PIO1_11, (IOCON_FUNC1 | IOCON_ADMODE_EN));
/* Setup GPIO PIO0_7 as an input (will kill LED out) */
Chip_GPIO_WriteDirBit(LPC_GPIO, 0, 7, false);
/* Use higher voltage trim for MCore48 board */
Chip_ADC_SetTrim(LPC_ADC, ADC_TRIM_VRANGE_HIGHV);
#endif
/* Need to do a calibration after initialization and trim */
Chip_ADC_StartCalibration(LPC_ADC);
while (!(Chip_ADC_IsCalibrationDone(LPC_ADC))) {}
/* Setup threshold 0 low and high values to about 25% and 75% of max */
Chip_ADC_SetThrLowValue(LPC_ADC, 0, ((1 * 0xFFF) / 4));
Chip_ADC_SetThrHighValue(LPC_ADC, 0, ((3 * 0xFFF) / 4));
/* Clear all pending interrupts */
Chip_ADC_ClearFlags(LPC_ADC, Chip_ADC_GetFlags(LPC_ADC));
/* Enable ADC overrun and sequence A completion interrupts */
Chip_ADC_EnableInt(LPC_ADC, (ADC_INTEN_SEQA_ENABLE | ADC_INTEN_OVRRUN_ENABLE));
/* Use threshold 0 for channel 1 and enable threshold interrupt mode for
channel as crossing */
Chip_ADC_SelectTH0Channels(LPC_ADC, ADC_THRSEL_CHAN_SEL_THR1(1));
Chip_ADC_SetThresholdInt(LPC_ADC, 1, ADC_INTEN_THCMP_CROSSING);
/* Enable ADC NVIC interrupt */
NVIC_EnableIRQ(ADC_A_IRQn);
/* Enable sequencer */
Chip_ADC_EnableSequencer(LPC_ADC, ADC_SEQA_IDX);
/* Setup SyTick for a periodic rate */
SysTick_Config(SystemCoreClock / TICKRATE_HZ);
/* Endless loop */
while (1) {
/* Sleep until something happens */
__WFI();
if (thresholdCrossed) {
thresholdCrossed = false;
DEBUGSTR("********ADC threshold event********\r\n");
}
/* Is a conversion sequence complete? */
if (sequenceComplete) {
sequenceComplete = false;
/* Get raw sample data for channels 1-8 */
for (j = 1; j <= 1; j++) {
rawSample = Chip_ADC_GetDataReg(LPC_ADC, j);
/* Show some ADC data */
DEBUGOUT("Sample value = 0x%x\r\n", ADC_DR_RESULT(rawSample));
DEBUGOUT("Threshold range = 0x%x\r\n", ADC_DR_THCMPRANGE(rawSample));
DEBUGOUT("Threshold cross = 0x%x\r\n", ADC_DR_THCMPCROSS(rawSample));
DEBUGOUT("Overrun = %d\r\n", ((rawSample & ADC_DR_OVERRUN) != 0));
DEBUGOUT("Data valid = %d\r\n", ((rawSample & ADC_SEQ_GDAT_DATAVALID) != 0));
DEBUGSTR("\r\n");
}
}
}
/* Should not run to here */
return 0;
}
/**
* @brief Handler for the systick timer; increments counters, etc.
*/
void SysTick_Handler(void) {
//static uint32_t blink_counter = 0;
static uint32_t sample_counter_temp = 0;
static uint32_t sample_counter_rh = 10;
static uint32_t sample_counter_mag = 20;
static int_fp mag_x=0, mag_y=0, mag_z=0;
static uint32_t sample_counter_range = 30;
static uint32_t left_sw_hold_counter = 0;
static uint8_t left_sw_engaged = 0;
static uint32_t right_sw_hold_counter = 0;
static uint8_t right_sw_engaged = 0;
g_delayms_counter += MS_PER_TICK;
sample_counter_temp++;
if (sample_counter_temp > SAMPLE_PERIOD_TEMP) {
Plot_AddSample(&g_plot_temp, HTU21D_GetTemp(&g_HTU21D));
sample_counter_temp = 0;
}
sample_counter_rh++;
if (sample_counter_rh > SAMPLE_PERIOD_RH) {
Plot_AddSample(&g_plot_rh, HTU21D_GetRH(&g_HTU21D));
sample_counter_rh = 0;
}
sample_counter_mag++;
if (sample_counter_mag > SAMPLE_PERIOD_MAG) {
HMC5883L_GetXYZ(&g_HMC5883L, &mag_x, &mag_y, &mag_z);
Plot_AddSample(&g_plot_mag, mag_z);
Compass_UpdateXY(&g_compass, mag_x, -mag_y);
sample_counter_mag = 0;
}
sample_counter_range++;
if (sample_counter_range > SAMPLE_PERIOD_RANGE) {
if (g_adc_sample_ready) {
g_adc_sample_ready = 0;
sample_counter_range = 0;
g_range_raw = ADC_DR_RESULT(Chip_ADC_GetDataReg(LPC_ADC, MoonLander_IO8_ADC));
Chip_ADC_StartSequencer(LPC_ADC, ADC_SEQA_IDX);
}
}
if (left_sw_engaged) {
if (Chip_GPIO_GetPinState(LPC_GPIO_PORT, 0, SW_LEFT)) {
left_sw_engaged = 0;
left_sw_hold_counter = 0;
}
else {
left_sw_hold_counter += MS_PER_TICK;
if (left_sw_hold_counter >= SW_OFF_HOLD_TIME_MS) {
g_go_to_sleep = 1;
left_sw_hold_counter = 0;
left_sw_engaged = 0;
}
}
}
if (right_sw_engaged) {
if (Chip_GPIO_GetPinState(LPC_GPIO_PORT, 0, SW_RIGHT)) {
right_sw_engaged = 0;
right_sw_hold_counter = 0;
}
else {
right_sw_hold_counter += MS_PER_TICK;
if (right_sw_hold_counter >= SW_OFF_HOLD_TIME_MS) {
g_go_to_sleep = 1;
right_sw_hold_counter = 0;
right_sw_engaged = 0;
}
}
}
if (g_sw_left_debouncing) {
left_sw_engaged = 1;
g_sw_left_debounce_counter += MS_PER_TICK;
if (g_sw_left_debounce_counter >= SW_DEBOUNCE_MS) {
g_sw_left_debouncing = 0;
g_sw_left_debounce_counter = 0;
}
}
if (g_sw_right_debouncing) {
right_sw_engaged = 1;
g_sw_right_debounce_counter += MS_PER_TICK;
if (g_sw_right_debounce_counter >= SW_DEBOUNCE_MS) {
g_sw_right_debouncing = 0;
g_sw_right_debounce_counter = 0;
}
}
g_millis_counter += MS_PER_TICK;
}
