/**
* \brief Main program function. Configure the hardware, initialize lwIP
* TCP/IP stack, and start HTTP service.
*/
int main(void)
{
/* Initialize the SAM system. */
system_init();
delay_init();
/* Setup USART module to output results */
setup_usart_channel();
/* Print example information. */
puts(STRING_HEADER);
/* Bring up the ethernet interface & initialize timer0, channel0. */
init_ethernet();
/* Bring up the web server. */
httpd_init();
/* Program main loop. */
while (1) {
/* Check for input packet and process it. */
ethernet_task();
}
}
/** Set up the measurement and comparison timer events.
* - Configure the reference timer to generate an event upon comparison
* match with channel 0.
* - Configure the measurement timer to trigger a capture when an event is
* received.
*/
static void setup_tc_events(void)
{
/* Enable incoming events on on measurement timer */
struct tc_events events_calib = { .on_event_perform_action = true };
tc_enable_events(&tc_calib, &events_calib);
/* Generate events from the reference timer on channel 0 compare match */
struct tc_events events_comp = { .generate_event_on_compare_channel[0] = true };
tc_enable_events(&tc_comp, &events_comp);
tc_enable(&tc_calib);
tc_enable(&tc_comp);
}
/** Set up the event system, linking the measurement and comparison timers so
* that events generated from the reference timer are linked to the measurement
* timer.
*/
static void setup_events(struct events_resource *event)
{
struct events_config config;
events_get_config_defaults(&config);
/* The event channel detects rising edges of the reference timer output
* event */
config.edge_detect = EVENTS_EDGE_DETECT_RISING;
config.path = EVENTS_PATH_SYNCHRONOUS;
config.generator = CONF_EVENT_GENERATOR_ID;
events_allocate(event, &config);
events_attach_user(event, CONF_EVENT_USED_ID);
}
/** Set up the USART for transmit-only communication at a fixed baud rate. */
static void setup_usart_channel(void)
{
struct usart_config cdc_uart_config;
usart_get_config_defaults(&cdc_uart_config);
/* Configure the USART settings and initialize the standard I/O library */
cdc_uart_config.mux_setting = EDBG_CDC_SERCOM_MUX_SETTING;
cdc_uart_config.pinmux_pad0 = EDBG_CDC_SERCOM_PINMUX_PAD0;
cdc_uart_config.pinmux_pad1 = EDBG_CDC_SERCOM_PINMUX_PAD1;
cdc_uart_config.pinmux_pad2 = EDBG_CDC_SERCOM_PINMUX_PAD2;
cdc_uart_config.pinmux_pad3 = EDBG_CDC_SERCOM_PINMUX_PAD3;
cdc_uart_config.baudrate = 115200;
stdio_serial_init(&usart_edbg, EDBG_CDC_MODULE, &cdc_uart_config);
usart_enable(&usart_edbg);
}
/** Set up the clock output pin so that the current system clock frequency can
* be monitored via an external frequency counter or oscilloscope. */
static void setup_clock_out_pin(void)
{
struct system_pinmux_config pin_mux;
system_pinmux_get_config_defaults(&pin_mux);
/* MUX out the system clock to a I/O pin of the device */
pin_mux.mux_position = CONF_CLOCK_PIN_MUX;
system_pinmux_pin_set_config(CONF_CLOCK_PIN_OUT, &pin_mux);
}
/** Retrieves the current system clock frequency, computed from the reference
* clock.
*
* \return Current system clock frequency in Hz.
*/
static uint32_t get_osc_frequency(void)
{
/* Clear any existing match status on the measurement timer */
tc_clear_status(&tc_comp, TC_STATUS_CHANNEL_0_MATCH);
/* Restart both measurement and reference timers */
tc_start_counter(&tc_calib);
tc_start_counter(&tc_comp);
/* Wait for the measurement timer to signal a compare match */
while (!(tc_get_status(&tc_comp) & TC_STATUS_CHANNEL_0_MATCH)) {
/* Wait for channel 0 match */
}
/* Compute the real clock frequency from the measurement timer count and
* reference count */
uint64_t tmp = tc_get_capture_value(&tc_calib, TC_COMPARE_CAPTURE_CHANNEL_0);
return ((tmp * REFERENCE_CLOCK_HZ) >> CALIBRATION_RESOLUTION);
}
int main(void)
{
struct events_resource event;
/* System initialization */
system_init();
delay_init();
/* Module initialization */
setup_tc_channels();
setup_tc_events();
setup_events(&event);
setup_clock_out_pin();
/* Init the variables with default calibration settings */
uint8_t frange_cal = SYSCTRL->OSC8M.bit.FRANGE;
uint8_t temp_cal = SYSCTRL->OSC8M.bit.CALIB >> TEMP_CAL_OFFSET;
uint8_t comm_cal = SYSCTRL->OSC8M.bit.CALIB & COMM_CAL_MAX;
/* Set the calibration test range */
uint8_t frange_cal_min = max((frange_cal - CONF_FRANGE_CAL), FRANGE_CAL_MIN);
uint8_t frange_cal_max = min((frange_cal + CONF_FRANGE_CAL), FRANGE_CAL_MAX);
uint8_t temp_cal_min = max((temp_cal - CONF_TEMP_CAL), TEMP_CAL_MIN);
uint8_t temp_cal_max = min((temp_cal + CONF_TEMP_CAL), TEMP_CAL_MAX);
/* Variables to track the previous and best calibration settings */
uint16_t comm_best = 0;
uint8_t frange_best = 0;
uint32_t freq_best = 0;
uint32_t freq_before = get_osc_frequency();
/* Run calibration loop */
for (frange_cal = frange_cal_min; frange_cal <= frange_cal_max; frange_cal++) {
for (temp_cal = temp_cal_min; temp_cal <= temp_cal_max; temp_cal++) {
for (comm_cal = COMM_CAL_MIN; comm_cal <= COMM_CAL_MAX; comm_cal++) {
/* Set the test calibration values */
system_clock_source_write_calibration(
SYSTEM_CLOCK_SOURCE_OSC8M, (temp_cal << 7) | comm_cal, frange_cal);
/* Wait for stabilization */
delay_cycles(1000);
/* Compute the deltas of the current and best system clock
* frequencies, save current settings if they are closer to the
* ideal frequency than the previous best values
*/
uint32_t freq_current = get_osc_frequency();
if (abs(freq_current - TARGET_FREQUENCY) < abs(freq_best - TARGET_FREQUENCY)) {
freq_best = freq_current;
comm_best = comm_cal;
frange_best = frange_cal;
port_pin_set_output_level(LED_0_PIN, LED_0_ACTIVE);
} else {
port_pin_set_output_level(LED_0_PIN, !LED_0_ACTIVE);
}
}
}
}
/* Set the found best calibration values */
system_clock_source_write_calibration(
SYSTEM_CLOCK_SOURCE_OSC8M, (temp_cal << 7) | comm_best, frange_best);
/* Setup USART module to output results */
setup_usart_channel();
/* Write previous and current frequency and new calibration settings to the
* USART
*/
printf("Freq Before: %lu\r\n", freq_before);
printf("Freq Best: %lu\r\n", freq_best);
printf("Freq Range: %u\r\n", frange_best);
printf("Calib Value: 0x%x\r\n", (temp_cal << 7) | comm_best);
/* Rapidly flash the board LED to signal the calibration completion */
while (1) {
port_pin_toggle_output_level(LED_0_PIN);
delay_ms(200);
}
}