//! [setup]
static void configure_tcc(void)
{
//! [setup_config]
struct tcc_config config_tcc;
//! [setup_config]
//! [setup_config_defaults]
tcc_get_config_defaults(&config_tcc, CONF_PWM_MODULE);
//! [setup_config_defaults]
//! [setup_change_config]
config_tcc.counter.period = 0xFFFF;
config_tcc.compare.wave_generation = TCC_WAVE_GENERATION_SINGLE_SLOPE_PWM;
config_tcc.compare.match[CONF_PWM_CHANNEL] = 0xFFFF;
//! [setup_change_config]
//! [setup_change_config_faults]
config_tcc.wave_ext.recoverable_fault[CONF_PWM_CHANNEL].source =
TCC_FAULT_SOURCE_ENABLE;
config_tcc.wave_ext.recoverable_fault[CONF_PWM_CHANNEL].halt_action =
TCC_FAULT_HALT_ACTION_SW_HALT;
//! [setup_change_config_faults]
//! [setup_change_config_pwm]
config_tcc.pins.enable_wave_out_pin[CONF_PWM_OUTPUT] = true;
config_tcc.pins.wave_out_pin[CONF_PWM_OUTPUT] = CONF_PWM_OUT_PIN;
config_tcc.pins.wave_out_pin_mux[CONF_PWM_OUTPUT] = CONF_PWM_OUT_MUX;
//! [setup_change_config_pwm]
//! [setup_set_config]
tcc_init(&tcc_instance, CONF_PWM_MODULE, &config_tcc);
//! [setup_set_config]
//! [setup_events]
struct tcc_events events;
memset(&events, 0, sizeof(struct tcc_events));
//! [setup_events]
//! [setup_change_events_faults]
events.on_event_perform_channel_action[CONF_PWM_CHANNEL] = true;
//! [setup_change_events_faults]
//! [setup_events_enable]
tcc_enable_events(&tcc_instance, &events);
//! [setup_events_enable]
//! [setup_enable]
tcc_enable(&tcc_instance);
//! [setup_enable]
}
//! [setup]
static void configure_tcc(void)
{
//! [setup_config]
struct tcc_config config_tcc;
//! [setup_config]
//! [setup_config_defaults]
tcc_get_config_defaults(&config_tcc, CONF_PWM_MODULE);
//! [setup_config_defaults]
//! [setup_change_config]
config_tcc.counter.period = 0xFFFF;
config_tcc.compare.wave_generation = TCC_WAVE_GENERATION_SINGLE_SLOPE_PWM;
config_tcc.compare.match[CONF_PWM_CHANNEL] = 0xFFFF;
//! [setup_change_config]
//! [setup_change_config_faults]
config_tcc.wave_ext.non_recoverable_fault[0].output = TCC_FAULT_STATE_OUTPUT_1;
//! [setup_change_config_faults]
//! [setup_change_config_pwm]
config_tcc.pins.enable_wave_out_pin[CONF_PWM_OUTPUT] = true;
config_tcc.pins.wave_out_pin[CONF_PWM_OUTPUT] = CONF_PWM_OUT_PIN;
config_tcc.pins.wave_out_pin_mux[CONF_PWM_OUTPUT] = CONF_PWM_OUT_MUX;
//! [setup_change_config_pwm]
//! [setup_set_config]
tcc_init(&tcc_instance, CONF_PWM_MODULE, &config_tcc);
//! [setup_set_config]
//! [setup_events]
struct tcc_events events;
memset(&events, 0, sizeof(struct tcc_events));
//! [setup_events]
//! [setup_change_events_faults]
events.on_input_event_perform_action[0] = true;
events.input_config[0].modify_action = true;
events.input_config[0].action = TCC_EVENT_ACTION_NON_RECOVERABLE_FAULT;
//! [setup_change_events_faults]
//! [setup_events_enable]
tcc_enable_events(&tcc_instance, &events);
//! [setup_events_enable]
//! [setup_enable]
tcc_enable(&tcc_instance);
//! [setup_enable]
}
static void configure_tcc_ramp2c_mode(void)
{
struct tcc_config config_tcc;
delay_init();
tcc_get_config_defaults(&config_tcc, TCC0);
/* Set up output pins */
/* CC2 will be included to generate ramp output WO[0] in RAMP2C mode*/
config_tcc.pins.enable_wave_out_pin[0] = true;
config_tcc.pins.wave_out_pin[0] = PIN_PA04E_TCC0_WO0;
config_tcc.pins.wave_out_pin_mux[0] = MUX_PA04E_TCC0_WO0;
/* CC1 will be included to generate ramp output WO[1] RAMP2C mode */
config_tcc.pins.enable_wave_out_pin[1] = true;
config_tcc.pins.wave_out_pin[1] = PIN_PA09E_TCC0_WO1;
config_tcc.pins.wave_out_pin_mux[1] = MUX_PA09E_TCC0_WO1;
/* Generator 1 as clock source */
config_tcc.counter.clock_source = GLCK_SOURCE;
config_tcc.counter.clock_prescaler = TCC_CLOCK_DIVIDER;
/* Set up initial period */
config_tcc.counter.period = PER_Value;
/* set CC0 */
/* CC0 will act as ramp A top in RAMP2C mode */
config_tcc.compare.match[0] = CC0_Value;
/* set compare reg CC1 & CC2 in RAMP2C mode */
config_tcc.compare.match[1] = CC1_Value;
config_tcc.compare.match[2] = CC2_Value;
/* Set up polarity output ramp */
config_tcc.compare.wave_polarity[1] = 1;
config_tcc.compare.wave_polarity[2] = 1;
/* Normal PWM in RAMP2 mode */
config_tcc.compare.wave_generation = TCC_WAVE_GENERATION_SINGLE_SLOPE_PWM;
config_tcc.compare.wave_ramp = TCC_RAMP_RAMP2;
#if (ENABLE_FAULT_BALNKING == true)
/* Set up recoverable fault A on virtual pulse */
config_tcc.wave_ext.recoverable_fault[0].qualification = true;
config_tcc.wave_ext.recoverable_fault[0].source = TCC_FAULT_SOURCE_ENABLE;
config_tcc.wave_ext.recoverable_fault[0].restart = true;
config_tcc.wave_ext.recoverable_fault[0].blanking_cycles = 10;
config_tcc.wave_ext.recoverable_fault[0].blanking = TCC_FAULT_BLANKING_RISING_EDGE;
/* Set up recoverable fault A on on WO */
config_tcc.wave_ext.recoverable_fault[1].qualification = true;
config_tcc.wave_ext.recoverable_fault[1].source = TCC_FAULT_SOURCE_ENABLE;
config_tcc.wave_ext.recoverable_fault[1].restart = true;
config_tcc.wave_ext.recoverable_fault[1].blanking_cycles = 10;
config_tcc.wave_ext.recoverable_fault[1].blanking = TCC_FAULT_BLANKING_RISING_EDGE;
#endif
/* Initialize with given configuration */
tcc_init(&tcc_inst, TCC0, &config_tcc);
/* RAMP2C mode */
while(TCC0->SYNCBUSY.reg & TCC_SYNCBUSY_WAVE);
TCC0->WAVE.bit.RAMP = TCC_WAVEB_RAMPB_RAMP2C_Val;
while(TCC0->SYNCBUSY.reg & TCC_SYNCBUSY_WAVE);
#if (ENABLE_FAULT_BALNKING == true)
/* set fault blanking prescaler*/
tcc_inst.hw->FCTRLA.reg |= 1 << BLANKPRESC;
tcc_inst.hw->FCTRLB.reg |= 1 << BLANKPRESC;
/* Enable recoverable fault event */
struct tcc_events events;
memset(&events, 0, sizeof(struct tcc_events));
events.on_event_perform_channel_action[0] = true;
events.on_event_perform_channel_action[1] = true;
tcc_enable_events(&tcc_inst, &events);
#endif
/* Enable TCC */
tcc_enable(&tcc_inst);
}
//! [setup]
static void configure_tcc(void)
{
//! [setup_config]
struct tcc_config config_tcc;
//! [setup_config]
//! [setup_config_defaults]
tcc_get_config_defaults(&config_tcc, CONF_PWM_MODULE);
//! [setup_config_defaults]
//! [setup_change_config]
config_tcc.counter.period = 0x1000;
config_tcc.compare.channel_function[CONF_TCC_CAPTURE_CHANNEL] =
TCC_CHANNEL_FUNCTION_CAPTURE;
config_tcc.compare.wave_generation = TCC_WAVE_GENERATION_SINGLE_SLOPE_PWM;
config_tcc.compare.wave_polarity[CONF_PWM_CHANNEL] = TCC_WAVE_POLARITY_0;
config_tcc.compare.match[CONF_PWM_CHANNEL] = compare_values[2];
//! [setup_change_config]
//! [setup_change_config_pwm]
config_tcc.pins.enable_wave_out_pin[CONF_PWM_OUTPUT] = true;
config_tcc.pins.wave_out_pin[CONF_PWM_OUTPUT] = CONF_PWM_OUT_PIN;
config_tcc.pins.wave_out_pin_mux[CONF_PWM_OUTPUT] = CONF_PWM_OUT_MUX;
//! [setup_change_config_pwm]
//! [setup_set_config]
tcc_init(&tcc_instance, CONF_PWM_MODULE, &config_tcc);
//! [setup_set_config]
//! [setup_events]
struct tcc_events events_tcc = {
.input_config[0].modify_action = false,
.input_config[1].modify_action = false,
.output_config.modify_generation_selection = false,
.generate_event_on_channel[CONF_PWM_CHANNEL] = true,
.on_event_perform_channel_action[CONF_TCC_CAPTURE_CHANNEL] = true
};
tcc_enable_events(&tcc_instance, &events_tcc);
//! [setup_events]
//! [setup_event_sys]
config_event_for_capture();
//! [setup_event_sys]
//! [setup_dma]
config_dma_for_capture();
config_dma_for_wave();
//! [setup_dma]
//! [setup_enable]
tcc_enable(&tcc_instance);
//! [setup_enable]
}
//! [setup]
int main(void)
{
system_init();
//! [setup_init]
configure_tcc();
//! [setup_init]
//! [main]
//! [main_loop]
while (true) {
/* Infinite loop */
}
//! [main_loop]
//! [main]
}
/**
* \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 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");
}
