void configure_dac_default(void){
configure_dac(0x1);
dac_ptr->CTRLB.reg |= 0x1; // Enable DAC output to Vout
while (dac_ptr->STATUS.reg & DAC_STATUS_SYNCBUSY);
}
int main(void)
{
system_init();
//! [setup_init]
configure_dac();
configure_dac_channel();
//! [setup_init]
//! [main]
//! [main_output_var]
uint16_t i = 0;
//! [main_output_var]
//! [main_loop]
while (1) {
//! [main_loop]
//! [main_write]
dac_chan_write(&dac_instance, DAC_CHANNEL_0, i);
//! [main_write]
//! [main_inc_val]
if (++i == 0x3FF) {
i = 0;
}
//! [main_inc_val]
}
//! [main]
}
*/
int main(void)
{
sysclk_init();
board_init();
uint16_t i ;
configure_LCD();
configure_dac();
configure_tc(1000);
configure_adc();
resolucao = 100;
deltaTeta = 2.0*PI/((float)resolucao);
valorMedio = MAX_AMPLITUDE_ANAG/2.0;
ili93xx_draw_pixmap(0,
ILI93XX_LCD_HEIGHT-100-1,
240-1,
100-1,
&image_data_maua[0]);
while (1) {
}
int main (void)
{
i = 0;
initialise_buffer();
INIT_IT();
LEDS_B_INIT();
ConfigTIM2();
ConfigADC();
configure_dac();
TIM2->CR1 |= 0x01;
while (1) //Boucle Infini
{
}
}
/**
* \brief Function for calibration the DAC using the internal ADC
*
* This function will calibrate the DAC using the internal ADC, please be aware
* that signals will be outputted on the DAC pins.
*
* When calibrating always start with the offset then do gain calibration.
*
*/
static void dac_calibrate(void)
{
/* Configure the DAC output pins */
configure_pins();
/* Configure the DAC for this calibration sequence */
configure_dac();
/* Configure the ADC for this calibration sequence */
configure_adc();
/* Calibrate offset and gain for DAC CH0 */
dac_calibrate_offset(DAC_CH0);
dac_calibrate_gain(DAC_CH0);
/* Calibrate offset and gain for DAC CH1 */
dac_calibrate_offset(DAC_CH1);
dac_calibrate_gain(DAC_CH1);
adc_disable(&CALIBRATION_ADC);
}
//! [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]
}
/**
* \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 */
}
}
}
