static void configure_eic(void)
{
struct extint_chan_conf config_extint_chan;
extint_chan_get_config_defaults(&config_extint_chan);
config_extint_chan.gpio_pin = PIN_PA11A_EIC_EXTINT11;
config_extint_chan.gpio_pin_mux = PINMUX_PA11A_EIC_EXTINT11;
config_extint_chan.gpio_pin_pull = EXTINT_PULL_DOWN;
config_extint_chan.detection_criteria = EXTINT_DETECT_HIGH;
extint_chan_set_config(11 , &config_extint_chan);
struct extint_events conf_extint_event;
memset(&conf_extint_event, 0, sizeof(struct extint_events));
conf_extint_event.generate_event_on_detect[11] = true;
extint_enable_events(&conf_extint_event);
}
//! [config_eic]
static void configure_eic(void)
{
//! [eic_chan_setup]
//! [eic_setup_1]
struct extint_chan_conf config;
//! [eic_setup_1]
//! [eic_setup_2]
extint_chan_get_config_defaults(&config);
//! [eic_setup_2]
//! [eic_setup_3]
config.filter_input_signal = true;
config.detection_criteria = EXTINT_DETECT_BOTH;
config.gpio_pin = CONF_FAULT_EIC_PIN;
config.gpio_pin_mux = CONF_FAULT_EIC_PIN_MUX;
//! [eic_setup_3]
//! [eic_setup_4]
extint_chan_set_config(CONF_FAULT_EIC_LINE, &config);
//! [eic_setup_4]
//! [eic_chan_setup]
//! [eic_event_setup]
//! [eic_event_setup_1]
struct extint_events events;
memset(&events, 0, sizeof(struct extint_events));
//! [eic_event_setup_1]
//! [eic_event_setup_2]
events.generate_event_on_detect[CONF_FAULT_EIC_LINE] = true;
//! [eic_event_setup_2]
//! [eic_event_setup_3]
extint_enable_events(&events);
//! [eic_event_setup_3]
//! [eic_event_setup]
//! [eic_callback_setup]
//! [eic_callback_setup_1]
extint_register_callback(eic_callback_to_clear_halt,
CONF_FAULT_EIC_LINE, EXTINT_CALLBACK_TYPE_DETECT);
//! [eic_callback_setup_1]
//! [eic_callback_setup_2]
extint_chan_enable_callback(CONF_FAULT_EIC_LINE,
EXTINT_CALLBACK_TYPE_DETECT);
//! [eic_callback_setup_2]
//! [eic_callback_setup]
}
/**
* \internal
* \brief Test Non-Recoverable Fault (FAULTx)
*
* This test uses TCC0 as a PWM generator (compare function).
* EXTINT will be used to route fault input to TCC0.
*
* \param test Current test case.
*/
static void run_faultx_test(const struct test_case *test)
{
test_assert_true(test,
tcc_init_success == true,
"TCC initialization failed, skipping test");
/* Configure TCC module for PWM generation with fault */
tcc_reset(&tcc_test0_module);
tcc_get_config_defaults(&tcc_test0_config, CONF_TEST_TCC0);
tcc_test0_config.counter.period = 0x03FF;
tcc_test0_config.compare.wave_generation =
TCC_WAVE_GENERATION_SINGLE_SLOPE_PWM;
tcc_test0_config.compare.match[TCC_MATCH_CAPTURE_CHANNEL_0] = 0x01FF;
tcc_test0_config.wave_ext.non_recoverable_fault[TCC_WAVE_OUTPUT_0].output = TCC_FAULT_STATE_OUTPUT_1;
tcc_init(&tcc_test0_module, CONF_TEST_TCC0, &tcc_test0_config);
/* Configure TCC events for non-recoverable fault input */
struct tcc_events tcc_test_events;
memset(&tcc_test_events, 0, sizeof(struct tcc_events));
tcc_test_events.on_input_event_perform_action[0] = true;
tcc_test_events.input_config[0].modify_action = true;
tcc_test_events.input_config[0].action = TCC_EVENT_ACTION_NON_RECOVERABLE_FAULT;
tcc_enable_events(&tcc_test0_module, &tcc_test_events);
tcc_enable(&tcc_test0_module);
/* Configure IO pin to generate fault */
struct port_config config_pin;
port_get_config_defaults(&config_pin);
config_pin.direction = PORT_PIN_DIR_OUTPUT;
port_pin_set_config(CONF_TEST_PIN_OUT, &config_pin);
port_pin_set_output_level(CONF_TEST_PIN_OUT, true);
/* Configure EIC to capture fault input */
struct extint_chan_conf config;
extint_chan_get_config_defaults(&config);
config.filter_input_signal = true;
config.detection_criteria = EXTINT_DETECT_BOTH;
config.gpio_pin = CONF_EIC_PIN;
config.gpio_pin_mux = CONF_EIC_MUX;
extint_chan_set_config(CONF_EIC_CHAN, &config);
struct extint_events extint_test_events;
memset(&extint_test_events, 0, sizeof(struct extint_events));
extint_test_events.generate_event_on_detect[CONF_EIC_CHAN] = true;
extint_enable_events(&extint_test_events);
/* Configure EVENTs to route fault input */
struct events_resource event_resource;
struct events_config event_config;
events_get_config_defaults(&event_config);
event_config.generator = CONF_EVENT_GENERATOR_ID;
event_config.path = EVENTS_PATH_ASYNCHRONOUS;
events_allocate(&event_resource, &event_config);
events_attach_user(&event_resource, CONF_EVENT_USER_ID_FAULTx);
/* Clear halt status */
tcc_clear_status(&tcc_test0_module,
TCC_STATUS_NON_RECOVERABLE_FAULT_PRESENT(0) |
TCC_STATUS_NON_RECOVERABLE_FAULT_OCCUR(0));
uint32_t test_val1 = tcc_get_count_value(&tcc_test0_module);
uint32_t test_val2 = tcc_get_count_value(&tcc_test0_module);
/* Check TCC is running */
test_assert_true(test,
test_val1 != test_val2,
"The counter failed to stop on non-recoverable fault");
/* Set fault */
port_pin_set_output_level(CONF_TEST_PIN_OUT, false);
/* Check fault state */
test_assert_true(test,
TCC_STATUS_NON_RECOVERABLE_FAULT_OCCUR(0) &
tcc_get_status(&tcc_test0_module),
"The counter failed to detect non-recoverable fault");
/* Check TCC is running */
test_val1 = tcc_get_count_value(&tcc_test0_module);
test_val2 = tcc_get_count_value(&tcc_test0_module);
test_assert_true(test,
test_val1 == test_val2,
"The counter failed to stop on non-recoverable fault");
}
/**
* \internal
* \brief Test capture and compare
*
* This test uses TC module 0 as a PWM generator (compare function).
* TC module 1 will be set to capture the signal from TC module 0 to test the capture
* functionality.
*
* \param test Current test case.
*/
static void run_16bit_capture_and_compare_test(const struct test_case *test)
{
test_assert_true(test,
tc_init_success == true,
"TC initialization failed, skipping test");
test_assert_true(test,
callback_function_entered == 1,
"The callback test has failed, skipping test");
/* Configure 16-bit TC module for PWM generation */
tc_reset(&tc_test0_module);
tc_get_config_defaults(&tc_test0_config);
tc_test0_config.wave_generation = TC_WAVE_GENERATION_MATCH_PWM;
tc_test0_config.counter_16_bit.compare_capture_channel[TC_COMPARE_CAPTURE_CHANNEL_0] = 0x03FF;
tc_test0_config.counter_16_bit.compare_capture_channel[TC_COMPARE_CAPTURE_CHANNEL_1] = 0x01FF;
/* Calculate the theoretical PWM frequency & duty */
uint32_t frequency_output, duty_output;
frequency_output = system_clock_source_get_hz(SYSTEM_CLOCK_SOURCE_OSC8M)/ (0x03FF+1);
/* This value is depend on the WaveGeneration Mode */
duty_output = (uint32_t)(tc_test0_config.counter_16_bit.compare_capture_channel[TC_COMPARE_CAPTURE_CHANNEL_1]) * 100 \
/ tc_test0_config.counter_16_bit.compare_capture_channel[TC_COMPARE_CAPTURE_CHANNEL_0];
tc_test0_config.pwm_channel[TC_COMPARE_CAPTURE_CHANNEL_1].enabled = true;
tc_test0_config.pwm_channel[TC_COMPARE_CAPTURE_CHANNEL_1].pin_out = CONF_TEST_PIN_OUT;
tc_test0_config.pwm_channel[TC_COMPARE_CAPTURE_CHANNEL_1].pin_mux = CONF_TEST_PIN_MUX;
tc_init(&tc_test0_module, CONF_TEST_TC0, &tc_test0_config);
tc_register_callback(&tc_test0_module, tc_callback_function, TC_CALLBACK_CC_CHANNEL0);
tc_enable_callback(&tc_test0_module, TC_CALLBACK_CC_CHANNEL0);
/* Configure 16-bit TC module for capture */
tc_reset(&tc_test1_module);
tc_get_config_defaults(&tc_test1_config);
tc_test1_config.clock_prescaler = TC_CLOCK_PRESCALER_DIV1;
tc_test1_config.enable_capture_on_channel[CONF_CAPTURE_CHAN_0] = true;
tc_test1_config.enable_capture_on_channel[CONF_CAPTURE_CHAN_1] = true;
tc_init(&tc_test1_module, CONF_TEST_TC1, &tc_test1_config);
struct tc_events tc_events = { .on_event_perform_action = true,
.event_action = TC_EVENT_ACTION_PPW,};
tc_enable_events(&tc_test1_module, &tc_events);
/* Configure external interrupt controller */
struct extint_chan_conf extint_chan_config;
extint_chan_config.gpio_pin = CONF_EIC_PIN;
extint_chan_config.gpio_pin_mux = CONF_EIC_MUX;
extint_chan_config.gpio_pin_pull = EXTINT_PULL_UP;
extint_chan_config.wake_if_sleeping = false;
extint_chan_config.filter_input_signal = false;
extint_chan_config.detection_criteria = EXTINT_DETECT_HIGH;
extint_chan_set_config(0, &extint_chan_config);
/* Configure external interrupt module to be event generator */
struct extint_events extint_event_conf;
extint_event_conf.generate_event_on_detect[0] = true;
extint_enable_events(&extint_event_conf);
/* Configure event system */
struct events_resource event_res;
/* Configure channel */
struct events_config config;
events_get_config_defaults(&config);
config.generator = CONF_EVENT_GENERATOR_ID;
config.edge_detect = EVENTS_EDGE_DETECT_NONE;
config.path = EVENTS_PATH_ASYNCHRONOUS;
events_allocate(&event_res, &config);
/* Configure user */
events_attach_user(&event_res, CONF_EVENT_USED_ID);
/* Enable TC modules */
tc_enable(&tc_test1_module);
tc_enable(&tc_test0_module);
uint16_t period_after_capture = 0;
uint16_t pulse_width_after_capture = 0;
uint32_t capture_frequency = 0;
uint32_t capture_duty = 0;
while (callback_function_entered < 4) {
period_after_capture = tc_get_capture_value(&tc_test1_module,
TC_COMPARE_CAPTURE_CHANNEL_0);
pulse_width_after_capture = tc_get_capture_value(&tc_test1_module,
TC_COMPARE_CAPTURE_CHANNEL_1);
}
if(period_after_capture != 0) {
capture_frequency = system_clock_source_get_hz(SYSTEM_CLOCK_SOURCE_OSC8M)/ period_after_capture;
capture_duty = (uint32_t)(pulse_width_after_capture) * 100 / period_after_capture;
}
test_assert_true(test,
(capture_frequency <= (frequency_output * (100 + CONF_TEST_TOLERANCE) / 100)) && \
(capture_frequency >= (frequency_output * (100 - CONF_TEST_TOLERANCE) / 100)) && \
(capture_duty <= (duty_output * (100 + CONF_TEST_TOLERANCE) / 100)) && \
(capture_duty >= (duty_output * (100 - CONF_TEST_TOLERANCE) / 100)) \
,"The result of Capture is wrong, captured frequency: %ldHz, captured duty: %ld%%",
capture_frequency,
capture_duty
);
}
/**
* \brief Initialize the USART for unit test
*
* Initializes the SERCOM USART used for sending the unit test status to the
* computer via the EDBG CDC gateway.
*/
static void cdc_uart_init(void)
{
struct usart_config usart_conf;
/* Configure USART for unit test output */
usart_get_config_defaults(&usart_conf);
usart_conf.mux_setting = CONF_STDIO_MUX_SETTING;
usart_conf.pinmux_pad0 = CONF_STDIO_PINMUX_PAD0;
usart_conf.pinmux_pad1 = CONF_STDIO_PINMUX_PAD1;
usart_conf.pinmux_pad2 = CONF_STDIO_PINMUX_PAD2;
usart_conf.pinmux_pad3 = CONF_STDIO_PINMUX_PAD3;
usart_conf.baudrate = CONF_STDIO_BAUDRATE;
stdio_serial_init(&cdc_uart_module, CONF_STDIO_USART, &usart_conf);
usart_enable(&cdc_uart_module);
}
/**
* \brief Run TC unit tests
*
* Initializes the system and serial output, then sets up the TC unit test
* suite and runs it.
*/
int main(void)
{
system_init();
cdc_uart_init();
/* Define Test Cases */
DEFINE_TEST_CASE(init_test, NULL,
run_init_test, NULL,
"Initialize tc_xmodules");
DEFINE_TEST_CASE(basic_functionality_test, NULL,
run_basic_functionality_test, NULL,
"test start stop and getters and setters");
DEFINE_TEST_CASE(callback_test, NULL,
run_callback_test, NULL,
"test callback API");
DEFINE_TEST_CASE(reset_32bit_master_test, NULL,
run_reset_32bit_master_test, NULL,
"Setup, reset and reinitialize TC modules of a 32-bit TC");
DEFINE_TEST_CASE(capture_and_compare_test, NULL,
run_16bit_capture_and_compare_test, NULL,
"Test capture and compare");
/* Put test case addresses in an array */
DEFINE_TEST_ARRAY(tc_tests) = {
&init_test,
&basic_functionality_test,
&callback_test,
&reset_32bit_master_test,
&capture_and_compare_test,
};
/* Define the test suite */
DEFINE_TEST_SUITE(tc_suite, tc_tests,
"SAM TC driver test suite");
/* Run all tests in the suite*/
test_suite_run(&tc_suite);
tc_reset(&tc_test0_module);
tc_reset(&tc_test1_module);
while (true) {
/* Intentionally left empty */
}
}
/**
* \internal
* \brief Test capture and compare
*
* This test uses TCC0 as a PWM generator (compare function). TCC1 will be set
* to capture the signal from TCC0 to test the capture functionality.
*
* \param test Current test case.
*/
static void run_capture_and_compare_test(const struct test_case *test)
{
test_assert_true(test,
tcc_init_success == true,
"TCC initialization failed, skipping test");
test_assert_true(test,
callback_function_entered == 1,
"The callback test has failed, skipping test");
/* Configure TCC module for PWM generation */
tcc_reset(&tcc_test0_module);
tcc_get_config_defaults(&tcc_test0_config, CONF_TEST_TCC0);
tcc_test0_config.counter.period = 0x03FF;
tcc_test0_config.compare.wave_generation =
TCC_WAVE_GENERATION_SINGLE_SLOPE_PWM;
tcc_test0_config.compare.match[TCC_MATCH_CAPTURE_CHANNEL_0] = 0x01FF;
/* Calculate the theoretical PWM frequency & duty */
uint32_t frequency_output, duty_output;
frequency_output = system_clock_source_get_hz(SYSTEM_CLOCK_SOURCE_OSC8M) / (0x03FF+1);
/* This value is depend on the WaveGeneration Mode */
duty_output = (uint32_t)(tcc_test0_config.compare.match[TCC_MATCH_CAPTURE_CHANNEL_0] * 100) /
tcc_test0_config.counter.period;
tcc_test0_config.pins.enable_wave_out_pin[TCC_MATCH_CAPTURE_CHANNEL_0] = true;
tcc_test0_config.pins.wave_out_pin[TCC_MATCH_CAPTURE_CHANNEL_0] = CONF_TEST_PIN_OUT;
tcc_test0_config.pins.wave_out_pin_mux[TCC_MATCH_CAPTURE_CHANNEL_0] = CONF_TEST_PIN_MUX;
tcc_init(&tcc_test0_module, CONF_TEST_TCC0, &tcc_test0_config);
tcc_register_callback(&tcc_test0_module, tcc_callback_function, TCC_CALLBACK_CHANNEL_0);
tcc_enable_callback(&tcc_test0_module, TCC_CALLBACK_CHANNEL_0);
/* Configure TCC module for capture */
tcc_reset(&tcc_test1_module);
tcc_get_config_defaults(&tcc_test1_config, CONF_TEST_TCC1);
tcc_test1_config.counter.period = 0xFFFF;
tcc_test1_config.counter.clock_prescaler = TCC_CLOCK_PRESCALER_DIV1;
tcc_test1_config.capture.channel_function[CONF_CAPTURE_CHAN_0] = TCC_CHANNEL_FUNCTION_CAPTURE;
tcc_test1_config.capture.channel_function[CONF_CAPTURE_CHAN_1] = TCC_CHANNEL_FUNCTION_CAPTURE;
tcc_init(&tcc_test1_module, CONF_TEST_TCC1, &tcc_test1_config);
struct tcc_events tcc_events = {
.on_input_event_perform_action[1] = true,
.input_config[1].modify_action = true,
.input_config[1].action = TCC_EVENT_ACTION_PERIOD_PULSE_WIDTH_CAPTURE
};
tcc_enable_events(&tcc_test1_module, &tcc_events);
/* Configure external interrupt controller */
struct extint_chan_conf extint_chan_config;
extint_chan_config.gpio_pin = CONF_EIC_PIN;
extint_chan_config.gpio_pin_mux = CONF_EIC_MUX;
extint_chan_config.gpio_pin_pull = EXTINT_PULL_UP;
extint_chan_config.wake_if_sleeping = false;
extint_chan_config.filter_input_signal = false;
extint_chan_config.detection_criteria = EXTINT_DETECT_HIGH;
extint_chan_set_config(CONF_EIC_CHAN, &extint_chan_config);
/* Configure external interrupt module to be event generator */
struct extint_events extint_event_conf;
extint_event_conf.generate_event_on_detect[CONF_EIC_CHAN] = true;
extint_enable_events(&extint_event_conf);
/* Configure event system */
struct events_resource event_res;
/* Configure channel */
struct events_config config;
events_get_config_defaults(&config);
config.generator = CONF_EVENT_GENERATOR_ID;
config.edge_detect = EVENTS_EDGE_DETECT_NONE;
config.path = EVENTS_PATH_ASYNCHRONOUS;
events_allocate(&event_res, &config);
/* Configure user */
events_attach_user(&event_res, CONF_EVENT_USED_ID);
/* Enable TCC modules */
tcc_enable(&tcc_test1_module);
tcc_enable(&tcc_test0_module);
uint16_t period_after_capture = 0;
uint16_t pulse_width_after_capture = 0;
uint32_t capture_frequency = 0;
uint32_t capture_duty = 0;
while (callback_function_entered < 4) {
period_after_capture = tcc_get_capture_value(&tcc_test1_module,
TCC_MATCH_CAPTURE_CHANNEL_0);
pulse_width_after_capture = tcc_get_capture_value(&tcc_test1_module,
TCC_MATCH_CAPTURE_CHANNEL_1);
}
if(period_after_capture != 0) {
capture_frequency =
system_clock_source_get_hz(SYSTEM_CLOCK_SOURCE_OSC8M) /
period_after_capture;
capture_duty = (uint32_t)(pulse_width_after_capture) * 100 /
period_after_capture;
}
test_assert_true(test,
(capture_frequency <= (frequency_output * (100 + CONF_TEST_TOLERANCE) / 100)) && \
(capture_frequency >= (frequency_output * (100 - CONF_TEST_TOLERANCE) / 100)) && \
(capture_duty <= (duty_output * (100 + CONF_TEST_TOLERANCE) / 100)) && \
(capture_duty >= (duty_output * (100 - CONF_TEST_TOLERANCE) / 100)) \
,"The result of Capture is wrong, captured frequency: %ldHz, captured duty: %ld%%",
capture_frequency,
capture_duty
);
}
/**
* \internal
* \brief Test Recoverable Fault (FAULTn)
*
* This test uses TCC0 as a PWM generator (compare function).
* EXTINT will be used to route fault input to TCC0.
*
* \param test Current test case.
*/
static void run_faultn_test(const struct test_case *test)
{
test_assert_true(test,
tcc_init_success == true,
"TCC initialization failed, skipping test");
/* Configure TCC module for PWM generation with fault */
tcc_reset(&tcc_test0_module);
tcc_get_config_defaults(&tcc_test0_config, CONF_TEST_TCC0);
tcc_test0_config.counter.period = 0x03FF;
tcc_test0_config.compare.wave_generation =
TCC_WAVE_GENERATION_SINGLE_SLOPE_PWM;
tcc_test0_config.compare.match[TCC_MATCH_CAPTURE_CHANNEL_0] = 0x01FF;
tcc_test0_config.wave_ext.recoverable_fault[TCC_MATCH_CAPTURE_CHANNEL_0].source = TCC_FAULT_SOURCE_ENABLE;
tcc_test0_config.wave_ext.recoverable_fault[TCC_MATCH_CAPTURE_CHANNEL_0].halt_action = TCC_FAULT_HALT_ACTION_SW_HALT;
tcc_init(&tcc_test0_module, CONF_TEST_TCC0, &tcc_test0_config);
/* Configure TCC events for recoverable fault input */
struct tcc_events tcc_test_events;
memset(&tcc_test_events, 0, sizeof(struct tcc_events));
tcc_test_events.on_event_perform_channel_action[TCC_MATCH_CAPTURE_CHANNEL_0] = true;
tcc_enable_events(&tcc_test0_module, &tcc_test_events);
tcc_enable(&tcc_test0_module);
/* Configure IO pin to generate fault */
struct port_config config_pin;
port_get_config_defaults(&config_pin);
config_pin.direction = PORT_PIN_DIR_OUTPUT;
port_pin_set_config(CONF_TEST_PIN_OUT, &config_pin);
port_pin_set_output_level(CONF_TEST_PIN_OUT, true);
/* Configure EIC to capture fault input */
struct extint_chan_conf config;
extint_chan_get_config_defaults(&config);
config.filter_input_signal = true;
config.detection_criteria = EXTINT_DETECT_BOTH;
config.gpio_pin = CONF_EIC_PIN;
config.gpio_pin_mux = CONF_EIC_MUX;
extint_chan_set_config(CONF_EIC_CHAN, &config);
struct extint_events extint_test_events;
memset(&extint_test_events, 0, sizeof(struct extint_events));
extint_test_events.generate_event_on_detect[CONF_EIC_CHAN] = true;
extint_enable_events(&extint_test_events);
/* Configure EVENTs to route fault input */
struct events_resource event_resource;
struct events_config event_config;
events_get_config_defaults(&event_config);
event_config.generator = CONF_EVENT_GENERATOR_ID;
event_config.path = EVENTS_PATH_ASYNCHRONOUS;
events_allocate(&event_resource, &event_config);
events_attach_user(&event_resource, CONF_EVENT_USER_ID_FAULTn);
/* Clear halt status */
tcc_clear_status(&tcc_test0_module,
TCC_STATUS_RECOVERABLE_FAULT_PRESENT(0) |
TCC_STATUS_RECOVERABLE_FAULT_OCCUR(0));
uint32_t test_val1 = tcc_get_count_value(&tcc_test0_module);
uint32_t test_val2 = tcc_get_count_value(&tcc_test0_module);
/* Check TCC is running */
test_assert_true(test,
test_val1 != test_val2,
"The counter failed to stop on recoverable fault");
/* Set fault */
port_pin_set_output_level(CONF_TEST_PIN_OUT, false);
/* Check fault state */
test_assert_true(test,
TCC_STATUS_RECOVERABLE_FAULT_OCCUR(0) &
tcc_get_status(&tcc_test0_module),
"The counter failed to detect recoverable fault");
/* Check TCC is running */
test_val1 = tcc_get_count_value(&tcc_test0_module);
test_val2 = tcc_get_count_value(&tcc_test0_module);
test_assert_true(test,
test_val1 == test_val2,
"The counter failed to stop on recoverable fault");
}
