int main (void)
{
SystemInit();
adc_pin_enable(AIN0, MASK_ENABLE);
adc_pin_enable(AIN1, MASK_ENABLE);
#if ADC_EXT_REF_EN==TRUE
adc_pin_enable(AIN2, MASK_ENABLE);
adc_pin_enable(AIN3, MASK_ENABLE);
#endif
#if (__AHB_CLK == 32000UL)
uart_init(QN_UART0, __USART_CLK, UART_1200);
#else
uart_init(QN_UART0, __USART_CLK, UART_115200);
#endif
uart_tx_enable(QN_UART0, MASK_ENABLE);
// ADC initialization
#if ADC_WORKING_AT_32K==TRUE
clk32k_enable(__32K_TYPE);
adc_init(ADC_SINGLE_WITHOUT_BUF_DRV, ADC_CLK32K_16000, ADC_INT_REF, ADC_12BIT);
#else
#if ADC_EXT_REF_EN==TRUE
adc_init(ADC_SINGLE_WITHOUT_BUF_DRV, ADC_CLK_1000000, ADC_EXT_REF2, ADC_12BIT);
//adc_init(ADC_SINGLE_WITHOUT_BUF_DRV, ADC_CLK_1000000, ADC_EXT_REF1, ADC_12BIT);
#else
adc_init(ADC_SINGLE_WITHOUT_BUF_DRV, ADC_CLK_1000000, ADC_INT_REF, ADC_12BIT);
#endif
#endif
// Read configuration
adc_read_configuration read_cfg;
#if ADC_TRIG_BY_GPIO == TRUE
read_cfg.trig_src = ADC_TRIG_GPIO;
syscon_SetPMCR2WithMask(QN_SYSCON, SYSCON_MASK_ADCT_PIN_SEL, ADC_GPIO15_TRIG);
// triger by gpio in single or single scan mode, connect PWM output to ADC trigger PIN
pwm_init(PWM_CH0);
pwm_config(PWM_CH0, PWM_PSCAL_DIV, PWM_COUNT_US(50, PWM_PSCAL_DIV), PWM_COUNT_US(25, PWM_PSCAL_DIV));
pwm_enable(PWM_CH0, MASK_ENABLE);
#elif ADC_TRIG_BY_TOF == TRUE
read_cfg.trig_src = ADC_TRIG_TOVF1;
// triger by timer1 overflow
timer_init(QN_TIMER1, NULL);
timer_pwm_config(QN_TIMER1, TIMER_PSCAL_DIV, TIMER_COUNT_US(100, TIMER_PSCAL_DIV), TIMER_COUNT_US(50, TIMER_PSCAL_DIV));
timer_enable(QN_TIMER1, MASK_ENABLE);
#elif ADC_TRIG_BY_SOFT == TRUE
read_cfg.trig_src = ADC_TRIG_SOFT;
#endif
#if ADC_DECIMATION_EN == TRUE
adc_decimation_enable(DECI_RATE_64, MASK_ENABLE);
#endif
#if ADC_COMPARATOR_EN == TRUE
//adc_compare_init(DECI_DATA, 2500, -2000, adc_WCMP_cb);
adc_compare_init(ADC_DATA, 600, -600, adc_WCMP_cb);
#endif
#if (ADC_TRIG_BY_GPIO==TRUE || ADC_TRIG_BY_TOF==TRUE || ADC_TRIG_BY_SOFT==TRUE)
adc_done = 0;
// modify here
read_cfg.mode = SINGLE_MOD;
read_cfg.start_ch = AIN0;
read_cfg.end_ch = AIN0;
adc_read(&read_cfg, buf, 512, adc_test_cb);
while (adc_done == 0);
#endif
#if ADC_COMPARATOR_EN == TRUE
int m = 0;
int n = 0;
for (int i = 0; i < 512; i++) {
if (buf[i] > 600) {
m++;
}
else if (buf[i] < -600) {
n++;
}
}
printf("m = %d\t n = %d\r\n", m, n);
#endif
for (int i = 0; i < 512; i++) {
printf("%d\t %d\r\n", buf[i], ADC_RESULT_mV(buf[i]));
}
int sum = 0;
for (int i = 0; i < 10; i++) {
sum += buf[511 - 2*i];
}
sum = sum / 10;
printf("average: %d\t %d\r\n", sum, ADC_RESULT_mV(sum));
#if ADC_TEMP_SENSOR_EN==TRUE
temp_sensor_enable(MASK_ENABLE);
int16_t tempv;
adc_init(ADC_DIFF_WITH_BUF_DRV, ADC_CLK_1000000, ADC_INT_REF, ADC_12BIT);
adc_done = 0;
read_cfg.trig_src = ADC_TRIG_SOFT;
read_cfg.mode = SINGLE_MOD;
read_cfg.start_ch = TEMP;
read_cfg.end_ch = TEMP;
adc_read(&read_cfg, &tempv, 1, adc_test_cb);
while (adc_done == 0);
printf("temperature: %0.1f\r\n", (float)(TEMPERATURE_X10(tempv)/10.0));
#endif
#if ADC_BATT_MONITOR_EN==TRUE
battery_monitor_enable(MASK_ENABLE);
int16_t battv;
adc_init(ADC_SINGLE_WITH_BUF_DRV, ADC_CLK_1000000, ADC_INT_REF, ADC_12BIT);
adc_done = 0;
read_cfg.trig_src = ADC_TRIG_SOFT;
read_cfg.mode = SINGLE_MOD;
read_cfg.start_ch = BATT;
read_cfg.end_ch = BATT;
adc_read(&read_cfg, &battv, 1, adc_test_cb);
while (adc_done == 0);
printf("battery voltage: %d\r\n", 4*ADC_RESULT_mV(battv));
#endif
while (1) /* Loop forever */
{
}
}
int main (void)
{
SystemInit();
/* Initialize GPIO (sets up clock) */
gpio_init(NULL);
/* Set all pin to output */
gpio_set_direction_field(LED_PINS, (uint32_t)GPIO_OUTPUT);
gpio_write_pin_field(LED_PINS, (uint32_t)GPIO_HIGH);
#if TIMER_INTERRUPT_EXAMPLE
timer_init(QN_TIMER0, led0_link);
timer_config(QN_TIMER0, TIMER_PSCAL_DIV, TIMER_COUNT_US(1000, TIMER_PSCAL_DIV));
timer_enable(QN_TIMER0, MASK_ENABLE);
timer_init(QN_TIMER1, led1_link);
timer_config(QN_TIMER1, TIMER_PSCAL_DIV, TIMER_COUNT_US(2000, TIMER_PSCAL_DIV));
timer_enable(QN_TIMER1, MASK_ENABLE);
timer_init(QN_TIMER2, led2_link);
timer_config(QN_TIMER2, 10, TIMER_COUNT_MS(3, 10));
timer_enable(QN_TIMER2, MASK_ENABLE);
timer_init(QN_TIMER3, led3_link);
timer_config(QN_TIMER3, 10, TIMER_COUNT_MS(4, 10));
timer_enable(QN_TIMER3, MASK_ENABLE);
#endif
#if TIMER_PWM_EXAMPLE
//P3.5 will output pwm wave with period for 1000us and pulse for 500us
timer_init(QN_TIMER0, NULL);
timer_pwm_config(QN_TIMER0, TIMER_PSCAL_DIV, TIMER_COUNT_US(1000, TIMER_PSCAL_DIV), TIMER_COUNT_US(500, TIMER_PSCAL_DIV));
timer_enable(QN_TIMER0, MASK_ENABLE);
//P1.1 will output pwm wave with period for 2000us and pulse for 1000us
timer_init(QN_TIMER1, NULL);
timer_pwm_config(QN_TIMER1, TIMER_PSCAL_DIV, TIMER_COUNT_US(2000, TIMER_PSCAL_DIV), TIMER_COUNT_US(1000, TIMER_PSCAL_DIV));
timer_enable(QN_TIMER1, MASK_ENABLE);
//P2.6 will output pwm wave with period for 4ms and pulse for 2ms
timer_init(QN_TIMER2, NULL);
timer_pwm_config(QN_TIMER2, 10, TIMER_COUNT_MS(4, 10), TIMER_COUNT_MS(2, 10));
timer_enable(QN_TIMER2, MASK_ENABLE);
//P2.3 will output pwm wave with period for 6ms and pulse for 3ms
timer_init(QN_TIMER3, NULL);
timer_pwm_config(QN_TIMER3, 10, TIMER_COUNT_MS(6, 10), TIMER_COUNT_MS(3, 10));
timer_enable(QN_TIMER3, MASK_ENABLE);
#endif
#if TIMER_CAPTURE_TIMER_MOD_EXAMPLE
/*
* Capture timer mode is to capture trigger event, and record the time-stamp.
*
* Make sure the macro TIMER0_CAP_MODE is INCAP_TIMER_MOD.
*
* Timer0 will capture the P3.5 rising edge, and each rising edge will trigger
* the callback function, as the same time the counter value will transmit to
* timer0_env.count.
*
* Other timers are similar to this.
*/
timer_init(QN_TIMER0, timer0_callback);
timer_capture_config(QN_TIMER0, INCAP_TIMER_MOD, 0, 0, 0);
timer_enable(QN_TIMER0, MASK_ENABLE);
#endif
#if TIMER_CAPTURE_COUNTER_MOD_EXAMPLE
/*
* Capture event mode is to calculate the time of happened specified event with
* specified numbers.
*
* Make sure the macro TIMER0_CAP_MODE is INCAP_COUNTER_MOD.
*
* Timer0 will count the time during 5 times rising edge of P3.5. After that, the
* callback function will be called, as the same time the time value will transmit to
* timer0_env.count.
*
* Other timers are similar to this.
*/
timer_init(QN_TIMER0, timer0_callback);
timer_capture_config(QN_TIMER0, INCAP_COUNTER_MOD, 100, 0, 5);
timer_enable(QN_TIMER0, MASK_ENABLE);
#endif
#if TIMER_CAPTURE_EVENT_MOD_EXAMPLE
/*
* Capture conter mode is used to count the numbers of a special event during a specified period.
*
* Make sure the macro TIMER0_CAP_MODE is INCAP_EVENT_MOD.
*
* Timer0 will count the numbers of rising edge during 1000ms with P3.5, and each rising
* edge will trigger the callback function, as the same time the counter value will transmit
* to timer0_env.count.
*
* Other timers are similar to this.
*/
timer_init(QN_TIMER0, timer0_callback);
timer_capture_config(QN_TIMER0, INCAP_EVENT_MOD, 100, TIMER_COUNT_MS(1000, 100), 0);
timer_enable(QN_TIMER0, MASK_ENABLE);
#endif
while (1) /* Loop forever */
{
}
}
