/** * \brief Configures the DAC in event triggered mode. * * Configures the DAC to use the module's default configuration, with output * channel mode configured for event triggered conversions. * * \param dev_inst Pointer to the DAC module software instance to initialize */ static void configure_dac(struct dac_module *dac_module) { struct dac_config config; struct dac_chan_config channel_config; /* Get the DAC default configuration */ dac_get_config_defaults(&config); /* Switch to GCLK generator 0 */ config.clock_source = GCLK_GENERATOR_0; dac_init(dac_module, DAC, &config); /* Get the default DAC channel config */ dac_chan_get_config_defaults(&channel_config); /* Set the channel configuration, and enable it */ dac_chan_set_config(dac_module, DAC_CHANNEL_0, &channel_config); dac_chan_enable(dac_module, DAC_CHANNEL_0); /* Enable event triggered conversions */ struct dac_events events = { .on_event_start_conversion = true }; dac_enable_events(dac_module, &events); dac_enable(dac_module); } /** * \brief Configures the TC to generate output events at the sample frequency. * * Configures the TC in Frequency Generation mode, with an event output once * each time the audio sample frequency period expires. * * \param dev_inst Pointer to the TC module software instance to initialize */ static void configure_tc(struct tc_module *tc_module) { struct tc_config config; tc_get_config_defaults(&config); config.clock_source = GCLK_GENERATOR_0; config.wave_generation = TC_WAVE_GENERATION_MATCH_FREQ; tc_init(tc_module, TC3, &config); /* Enable periodic event output generation */ struct tc_events events = { .generate_event_on_overflow = true }; tc_enable_events(tc_module, &events); /* Set the timer top value to alter the overflow frequency */ tc_set_top_value(tc_module, system_gclk_gen_get_hz(GCLK_GENERATOR_0) / sample_rate); tc_enable(tc_module); } /** * \brief Configures the event system to link the sample timer to the DAC. * * Configures the event system, linking the TC module used for the audio sample * rate timing to the DAC, so that a new conversion is triggered each time the * DAC receives an event from the timer. */ static void configure_events(struct events_resource *event) { struct events_config config; events_get_config_defaults(&config); config.generator = EVSYS_ID_GEN_TC3_OVF; config.path = EVENTS_PATH_ASYNCHRONOUS; events_allocate(event, &config); events_attach_user(event, EVSYS_ID_USER_DAC_START); } /** * \brief Main application routine */ int main(void) { struct dac_module dac_module; struct tc_module tc_module; struct events_resource event; /* Initialize all the system clocks, pm, gclk... */ system_init(); /* Enable the internal bandgap to use as reference to the DAC */ system_voltage_reference_enable(SYSTEM_VOLTAGE_REFERENCE_BANDGAP); /* Module configuration */ configure_tc(&tc_module); configure_dac(&dac_module); configure_events(&event); /* Start the sample trigger timer */ tc_start_counter(&tc_module); while (true) { while (port_pin_get_input_level(SW0_PIN) == SW0_INACTIVE) { /* Wait for the button to be pressed */ } port_pin_toggle_output_level(LED0_PIN); for (uint32_t i = 0; i < number_of_samples; i++) { dac_chan_write(&dac_module, DAC_CHANNEL_0, wav_samples[i]); while (!(DAC->INTFLAG.reg & DAC_INTFLAG_EMPTY)) { /* Wait for data buffer to be empty */ } } while (port_pin_get_input_level(SW0_PIN) == SW0_ACTIVE) { /* Wait for the button to be depressed */ } } }
//! [setup_dac] void configure_dac(void) { //! [setup_dac_config] struct dac_config config_dac; //! [setup_dac_config] //! [setup_dac_config_default] dac_get_config_defaults(&config_dac); //! [setup_dac_config_default] //! [setup_dac_start_on_event] #if (SAML21) dac_instance.start_on_event[DAC_CHANNEL_0] = true; #else dac_instance.start_on_event = true; #endif //! [setup_dac_start_on_event] //! [setup_dac_instance] dac_init(&dac_instance, DAC, &config_dac); //! [setup_dac_instance] //! [setup_dac_on_event_start_conversion] struct dac_events events = #if (SAML21) { .on_event_chan0_start_conversion = true }; #else { .on_event_start_conversion = true }; #endif //! [setup_dac_on_event_start_conversion] //! [enable_dac_event] dac_enable_events(&dac_instance, &events); //! [enable_dac_event] } //! [setup_dac] //! [setup_dac_channel] void configure_dac_channel(void) { //! [setup_dac_chan_config] struct dac_chan_config config_dac_chan; //! [setup_dac_chan_config] //! [setup_dac_chan_config_default] dac_chan_get_config_defaults(&config_dac_chan); //! [setup_dac_chan_config_default] //! [set_dac_chan_config] dac_chan_set_config(&dac_instance, DAC_CHANNEL_0, &config_dac_chan); //! [set_dac_chan_config] //! [enable_dac_channel] dac_chan_enable(&dac_instance, DAC_CHANNEL_0); //! [enable_dac_channel] } //! [setup_dac_channel] int main(void) { //! [data_length_var] uint32_t i; //! [data_length_var] system_init(); //! [setup_init] //! [init_rtc] configure_rtc_count(); //! [init_rtc] //! [set_rtc_period] rtc_count_set_period(&rtc_instance, 1); //! [set_rtc_period] //! [init_dac] configure_dac(); //! [init_dac] //! [init_dac_chan] configure_dac_channel(); //! [init_dac_chan] //! [enable_dac] dac_enable(&dac_instance); //! [enable_dac] //! [init_event_resource] configure_event_resource(); //! [init_event_resource] //! [register_dac_callback] dac_register_callback(&dac_instance, DAC_CHANNEL_0, dac_callback,DAC_CALLBACK_TRANSFER_COMPLETE); //! [register_dac_callback] //! [enable_dac_callback] dac_chan_enable_callback(&dac_instance, DAC_CHANNEL_0, DAC_CALLBACK_TRANSFER_COMPLETE); //! [enable_dac_callback] //! [setup_dac_data] for (i = 0;i < DATA_LENGTH;i++) { dac_data[i] = 0xfff * i; } //! [setup_dac_data] //! [setup_init] //! [main_start] //! [main_write] dac_chan_write_buffer_job(&dac_instance, DAC_CHANNEL_0, dac_data, DATA_LENGTH); //! [main_write] //! [main_check_transfer_done] while (!transfer_is_done) { /* Wait for transfer done */ } //! [main_check_transfer_done] //! [main_loop] while (1) { } //! [main_loop] //! [main_start] }
/* Timer 0 Initialization */ void timer_init(void) { struct tc_config conf_tc; struct tc_events conf_tc_events = {.generate_event_on_compare_channel[0] = 1}; tc_get_config_defaults(&conf_tc); conf_tc.clock_source = GCLK_GENERATOR_0; conf_tc.wave_generation = TC_WAVE_GENERATION_MATCH_FREQ; conf_tc.counter_16_bit.compare_capture_channel[0] = 0xFFFF; tc_init(&tc_inst, TC0, &conf_tc); tc_enable_events(&tc_inst, &conf_tc_events); tc_enable(&tc_inst); tc_stop_counter(&tc_inst); /* Enable TC0 match/capture channel 0 interrupt */ TC0->COUNT16.INTENSET.bit.MC0 = 1; /* Enable TC0 module interrupt */ NVIC_EnableIRQ(TC0_IRQn); } /* DAC Initialization */ void dac_initialize(void) { struct dac_config conf_dac; struct dac_events conf_dac_events = {.on_event_start_conversion = 1}; dac_get_config_defaults(&conf_dac); conf_dac.clock_source = GCLK_GENERATOR_3; conf_dac.reference = DAC_REFERENCE_INT1V; dac_init(&dac_inst, DAC, &conf_dac); dac_enable_events(&dac_inst, &conf_dac_events); dac_enable(&dac_inst); } /* Event System Initialization */ void evsys_init(void) { struct events_resource conf_event_resource; struct events_config conf_event; events_get_config_defaults(&conf_event); conf_event.edge_detect = EVENTS_EDGE_DETECT_NONE; conf_event.path = EVENTS_PATH_ASYNCHRONOUS; conf_event.generator = EVSYS_ID_GEN_TC0_MCX_0; events_allocate(&conf_event_resource, &conf_event); events_attach_user(&conf_event_resource, EVSYS_ID_USER_DAC_START); } /* Initialize the selected waveform buffer with output data */ void buffer_init(void) { #if WAVE_MODE==SINE_WAVE for (i = 0; i < DEGREES_PER_CYCLE; i++) { sine_wave_buf[i] = (uint16_t)(500 + (500*sin((double)i*DEGREE))); } #elif WAVE_MODE==SAW_TOOTH_WAVE for (i = 0; i < 256; i++) { sawtooth_wave_buf[i] = i*4; } #elif WAVE_MODE==TRIANGLE_WAVE for (i = 0; i < 128; i++) { triangle_wave_buf[i] = i*8; } for (i = 128; i < 256; i++) { triangle_wave_buf[i] = 1023 - (i*8); } #endif } /* Main function */ int main(void) { system_init(); timer_init(); dac_initialize(); evsys_init(); buffer_init(); /* Set the TC0 compare value corresponding to specified frequency */ #if WAVE_MODE==SINE_WAVE tc_set_compare_value(&tc_inst, 0, \ system_gclk_gen_get_hz(GCLK_GENERATOR_0)/(FREQUENCY*360)); #else tc_set_compare_value(&tc_inst, 0, \ system_gclk_gen_get_hz(GCLK_GENERATOR_0)/(FREQUENCY*256)); #endif /* Start TC0 timer */ tc_start_counter(&tc_inst); /* Enable global interrupt */ system_interrupt_enable_global(); while (true) { } }