/** Initializes the sensor platform - as this calls the board and sysclock
* init functions internally, it will also wait for any pending serial
* transfer(s) to complete before calling sensor_platform_init() and will
* re-initialize the USART afterwards to ensure no corrupt or lost data.
*/
static void configure_sensor_platform(void)
{
#if XMEGA
usart_clear_tx_complete(CONF_TEST_USART);
while (!usart_tx_is_complete(CONF_TEST_USART));
#elif UC3
while (!(usart_tx_empty(CONF_TEST_USART)));
#endif
sensor_platform_init();
stdio_serial_init(CONF_TEST_USART, &usart_serial_options);
}
/*! \brief Check whether there are data in Transmit Holding Register or
* Transmit Shift Register in SPI master mode.
*
* \param p_usart Base address of the USART instance.
*
* \retval 1 The two registers are empty.
* \retval 0 One of the two registers contains data.
*/
uint32_t usart_spi_is_tx_empty(volatile avr32_usart_t *p_usart)
{
return usart_tx_empty(p_usart);
}
/*! \brief The main function.
*/
int main(void)
{
int32_t result;
#if UC3L /* UC3L series only */
// Note: on the AT32UC3L-EK board, there is no crystal/external clock connected
// to the OSC0 pinout XIN0/XOUT0. We shall then program the DFLL and switch the
// main clock source to the DFLL.
pcl_configure_clocks(&pcl_dfll_freq_param);
// Note: since it is dynamically computing the appropriate field values of the
// configuration registers from the parameters structure, this function is not
// optimal in terms of code size. For a code size optimal solution, it is better
// to create a new function from pcl_configure_clocks_dfll0() and modify it
// to use preprocessor computation from pre-defined target frequencies.
#else // else for all other series
// Configure Osc0 in crystal mode (i.e. use of an external crystal source, with
// frequency FOSC0) with an appropriate startup time then switch the main clock
// source to Osc0.
pcl_switch_to_osc(PCL_OSC0, FOSC0, OSC0_STARTUP);
#endif
const gpio_map_t usart_gpio_map =
{
{EXAMPLE_USART_RX_PIN, EXAMPLE_USART_RX_FUNCTION},
{EXAMPLE_USART_TX_PIN, EXAMPLE_USART_TX_FUNCTION}
};
// Assign GPIO to USART.
gpio_enable_module(usart_gpio_map,
sizeof(usart_gpio_map) / sizeof(usart_gpio_map[0]));
static const usart_options_t usart_options =
{
.baudrate = 57600,
.charlength = 8,
.paritytype = USART_NO_PARITY,
.stopbits = USART_1_STOPBIT,
.channelmode = 0
};
// Initialize USART in RS232 mode.
usart_init_rs232(EXAMPLE_USART, &usart_options, FPBA);
usart_write_line(EXAMPLE_USART, "\x1B[2J\x1B[H\r\nATMEL\r\n");
usart_write_line(EXAMPLE_USART, "AVR UC3 - HMATRIX example\r\n\r\n");
// First test with AVR32_HMATRIX_DEFMSTR_TYPE_NO_DEFAULT
print(EXAMPLE_USART, "- Test 1 ----------------------------------------\r\n");
print(EXAMPLE_USART, "------ All Slave Default Master Types are: ------\r\n");
print(EXAMPLE_USART, " - No Default Master\r\n");
print(EXAMPLE_USART, " - leds Toggle: ");
print_ulong(EXAMPLE_USART, NB_TOGGLE);
print(EXAMPLE_USART, " times\r\n");
#if defined(AVR32_HMATRIX)
configure_hmatrix(AVR32_HMATRIX_DEFMSTR_TYPE_NO_DEFAULT);
#elif defined(AVR32_HMATRIXB)
configure_hmatrix(AVR32_HMATRIXB_DEFMSTR_TYPE_NO_DEFAULT);
#endif
result = toggle_led(NB_TOGGLE);
// Second test with AVR32_HMATRIX_DEFMSTR_TYPE_LAST_DEFAULT
print(EXAMPLE_USART, "- Test 2 ----------------------------------------\r\n");
print(EXAMPLE_USART, "------ All Slave Default Master Types are: ------\r\n");
print(EXAMPLE_USART, " - Last Default Master\r\n");
print(EXAMPLE_USART, " - No Default Master\r\n");
print(EXAMPLE_USART, " - leds Toggle: ");
print_ulong(EXAMPLE_USART, NB_TOGGLE);
print(EXAMPLE_USART, " times\r\n");
#if defined(AVR32_HMATRIX)
configure_hmatrix(AVR32_HMATRIX_DEFMSTR_TYPE_LAST_DEFAULT);
#elif defined(AVR32_HMATRIXB)
configure_hmatrix(AVR32_HMATRIXB_DEFMSTR_TYPE_LAST_DEFAULT);
#endif
result -= toggle_led(NB_TOGGLE);
print(EXAMPLE_USART, "--------------------------------------------------\r\n");
print_ulong(EXAMPLE_USART, result);
print(EXAMPLE_USART, " Cycles saved between test 1 and test 2\r\nDone!");
//*** Sleep mode
// This program won't be doing anything else from now on, so it might as well
// sleep.
// Modules communicating with external circuits should normally be disabled
// before entering a sleep mode that will stop the module operation.
// Make sure the USART dumps the last message completely before turning it off.
while(!usart_tx_empty(EXAMPLE_USART));
pcl_disable_module(EXAMPLE_USART_CLOCK_MASK);
// Since we're going into a sleep mode deeper than IDLE, all HSB masters must
// be stopped before entering the sleep mode: none is acting currently in this
// example so nothing to do for this example.
// If there is a chance that any PB write operations are incomplete, the CPU
// should perform a read operation from any register on the PB bus before
// executing the sleep instruction.
AVR32_INTC.ipr[0]; // Dummy read
// Go to STATIC sleep mode.
SLEEP(AVR32_PM_SMODE_STATIC);
while (true);
}
/*!
* \brief main function : do init and loop (poll if configured so)
*/
int main(void)
{
char temp[20];
char *ptemp;
uint32_t ast_alarm;
static const gpio_map_t USART_GPIO_MAP = {
{EXAMPLE_USART_RX_PIN, EXAMPLE_USART_RX_FUNCTION},
{EXAMPLE_USART_TX_PIN, EXAMPLE_USART_TX_FUNCTION}
};
/* USART options */
static const usart_options_t USART_OPTIONS = {
.baudrate = 57600,
.charlength = 8,
.paritytype = USART_NO_PARITY,
.stopbits = USART_1_STOPBIT,
.channelmode = 0
};
#if BOARD == UC3L_EK
scif_osc32_opt_t opt = {
/* 2-pin Crystal connected to XIN32/XOUT32 and high current
* mode. */
SCIF_OSC_MODE_2PIN_CRYSTAL_HICUR,
/* oscillator startup time */
AVR32_SCIF_OSCCTRL32_STARTUP_0_RCOSC,
/* select alternate xin32_2 and xout32_2 for 32kHz crystal
* oscillator */
true,
/* disable the 1kHz output */
false,
/* enable the 32kHz output */
true
};
#else
scif_osc32_opt_t opt;
opt.mode = SCIF_OSC_MODE_2PIN_CRYSTAL;
opt.startup = AVR32_SCIF_OSCCTRL32_STARTUP_0_RCOSC;
#endif
#if BOARD == UC3L_EK
/*
* Note: on the AT32UC3L-EK board, there is no crystal/external clock
* connected to the OSC0 pinout XIN0/XOUT0. We shall then program the
* DFLL and switch the main clock source to the DFLL.
*/
pcl_configure_clocks(&pcl_dfll_freq_param);
/*
* Note: since it is dynamically computing the appropriate field values
* of the configuration registers from the parameters structure, this
* function is not optimal in terms of code size. For a code size
* optimal solution, it is better to create a new function from
* pcl_configure_clocks_dfll0() and modify it to use preprocessor
* computation from pre-defined target frequencies.
*/
#else
pcl_switch_to_osc(PCL_OSC0, FOSC0, OSC0_STARTUP);
#endif
/* Start OSC_32KHZ */
scif_start_osc32(&opt, true);
/* Assign GPIO pins to USART0. */
gpio_enable_module(USART_GPIO_MAP,
sizeof(USART_GPIO_MAP) / sizeof(USART_GPIO_MAP[0]));
/* Initialize USART in RS232 mode */
usart_init_rs232(EXAMPLE_USART, &USART_OPTIONS, FPBA);
/* Welcome sentence // 2-pin Crystal and high current mode. */
/* Crystal is connected to XIN32/XOUT32. */
usart_write_line(EXAMPLE_USART, "\x1B[2J\x1B[H\r\nATMEL\r\n");
usart_write_line(EXAMPLE_USART, "AVR32 UC3 - AST example 2\r\n");
usart_write_line(EXAMPLE_USART,
"AST 32 KHz oscillator counter example.\r\n");
usart_write_line(EXAMPLE_USART,
"Alarm0 wakeup from static sleep mode every second.\r\n");
/* Using counter mode and set it to 0 */
unsigned long ast_counter = 0;
/* Initialize the AST */
if (!ast_init_counter(&AVR32_AST,
AST_OSC_32KHZ, AST_PSEL_32KHZ_1HZ, ast_counter)) {
usart_write_line(EXAMPLE_USART,
"Error initializing the AST\r\n");
while (1) {
}
}
/* Alarm 0 sends a wakeup signal to the Power manager */
ast_enable_alarm_async_wakeup(&AVR32_AST, 0);
/* Enable the AST */
ast_enable(&AVR32_AST);
while (1) {
/* disable alarm 0 */
ast_disable_alarm0(&AVR32_AST);
/* ast_init_counter Set Alarm to current time+30 seconds */
ast_alarm = ast_counter + 1;
ast_set_alarm0_value(&AVR32_AST, ast_alarm);
/* Enable alarm 0 */
ast_enable_alarm0(&AVR32_AST);
/*
* Precautions when entering a sleep mode
* Modules communicating with external circuits should normally
* be disabled before entering a sleep mode that will stop the
* module operation.
* Make sure the USART dumps the last message completely before
* turning it off.
*/
while (!usart_tx_empty(EXAMPLE_USART)) {
}
pcl_disable_module(EXAMPLE_USART_CLOCK_MASK);
/*
* Since we're going into a sleep mode deeper than IDLE, all HSB
* masters must be stopped before entering the sleep mode.
* Note: since we're not using the PDCA, we don't have to stop
*it.
*/
/*
* If there is a chance that any PB write operations are
*incomplete,
* the CPU should perform a read operation from any register on
*the
* PB bus before executing the sleep instruction.
*/
AVR32_INTC.ipr[0]; /* Dummy read */
/* Go into static sleep mode */
SLEEP(AVR32_PM_SMODE_STATIC);
/* We're out of the static sleep mode now => re-enable the USART
* module */
pcl_enable_module(EXAMPLE_USART_CLOCK_MASK);
/* After wake up, clear the Alarm0 */
ast_clear_alarm_status_flag(&AVR32_AST, 0);
/* Toggle Led0 */
gpio_tgl_gpio_pin(LED0_GPIO);
/* Set cursor to the position (1; 6) */
usart_write_line(EXAMPLE_USART, "\x1B[6;1H");
ast_counter = ast_get_counter_value(&AVR32_AST);
usart_write_line(EXAMPLE_USART, "Timer: ");
ptemp = print_i(temp, ast_counter);
usart_write_line(EXAMPLE_USART, ptemp);
usart_write_line(EXAMPLE_USART, " sec ");
}
}
/**
* \brief Initialize ADC driver to read the board temperature sensor.
*
* Initializes the board's ADC driver module and configures the ADC channel
* connected to the onboard NTC temperature sensor ready for conversions.
*/
static void init_adc(void)
{
// Assign and enable GPIO pin to the ADC function.
gpio_enable_module_pin(ADC_TEMPERATURE_PIN, ADC_TEMPERATURE_FUNCTION);
const adcifb_opt_t adcifb_opt = {
.resolution = AVR32_ADCIFB_ACR_RES_12BIT,
.shtim = 15,
.ratio_clkadcifb_clkadc = 2,
.startup = 3,
.sleep_mode_enable = false
};
// Enable and configure the ADCIFB module
sysclk_enable_peripheral_clock(&AVR32_ADCIFB);
adcifb_configure(&AVR32_ADCIFB, &adcifb_opt);
// Configure the trigger (No trigger, only software trigger)
adcifb_configure_trigger(&AVR32_ADCIFB, AVR32_ADCIFB_TRGMOD_NT, 0);
// Enable the ADCIFB channel to NTC temperature sensor
adcifb_channels_enable(&AVR32_ADCIFB, ADC_TEMPERATURE_CHANNEL);
}
/**
* \brief Initializes the USART.
*
* Initializes the board USART ready for serial data to be transmitted and
* received.
*/
static void init_usart(void)
{
const usart_options_t usart_options = {
.baudrate = 57600,
.charlength = 8,
.paritytype = USART_NO_PARITY,
.stopbits = USART_1_STOPBIT,
.channelmode = USART_NORMAL_CHMODE
};
// Initialize USART in RS232 mode with the requested settings.
sysclk_enable_peripheral_clock(USART);
usart_init_rs232(USART, &usart_options, sysclk_get_pba_hz());
}
/**
* \brief Initializes the PWM subsystem ready to generate the RGB LED PWM
* waves.
*
* Initializes the on-chip PWM module and configures the RGB LED PWM outputs so
* the the brightness of the three individual channels can be adjusted.
*/
static void init_pwm(void)
{
// GPIO pin/function map for the RGB LEDs.
gpio_enable_module_pin(LED_RED_PWMA, LED_PWMA_FUNCTION);
gpio_enable_module_pin(LED_GREEN_PWMA, LED_PWMA_FUNCTION);
gpio_enable_module_pin(LED_BLUE_PWMA, LED_PWMA_FUNCTION);
const scif_gclk_opt_t genclk3_opt = {
.clock_source = SCIF_GCCTRL_CPUCLOCK,
.divider = 8,
.diven = true,
};
// Start generic clock 3 for the PWM outputs.
scif_start_gclk(AVR32_PM_GCLK_GCLK3, &genclk3_opt);
// Enable RGB LED PWM.
sysclk_enable_peripheral_clock(&AVR32_PWMA);
pwma_config_enable(&AVR32_PWMA,EXAMPLE_PWMA_FREQUENCY,EXAMPLE_PWMA_GCLK_FREQUENCY,0);
pwma_set_channels_value(&AVR32_PWMA,PWM_CHANNEL_RED | PWM_CHANNEL_BLUE| PWM_CHANNEL_GREEN,255);
}
/**
* \brief Application main loop.
*/
int main(void)
{
board_init();
sysclk_init();
sysclk_enable_peripheral_clock(USART);
// Initialize touch, ADC, USART and PWM
init_adc();
init_usart();
init_pwm();
init_touch();
while (true) {
uint32_t adc_data;
// Read slider and button and update RGB led
touch_handler();
// Wait until the ADC is ready to perform a conversion.
do { } while (!adcifb_is_ready(&AVR32_ADCIFB));
// Start an ADCIFB conversion sequence.
adcifb_start_conversion_sequence(&AVR32_ADCIFB);
// Wait until the converted data is available.
do { } while (!adcifb_is_drdy(&AVR32_ADCIFB));
// Get the last converted data.
adc_data = (adcifb_get_last_data(&AVR32_ADCIFB) & 0x3FF);
// Write temperature data to USART
do { } while (!usart_tx_empty(USART));
usart_write_char(USART, (adc_data >> 8));
do { } while (!usart_tx_empty(USART));
usart_write_char(USART, (adc_data & 0xFF));
}
}