/**
* \brief Test backup mode.
*
* \note To test backup mode, the program must run out of flash.
*/
static void test_backup_mode(void)
{
puts(STRING_BACKUP);
#if SAMG55
/* Wait for the transmission done before changing clock */
while (!usart_is_tx_empty(CONSOLE_UART)) {
}
#else
/* Wait for the transmission done before changing clock */
while (!uart_is_tx_empty(CONSOLE_UART)) {
}
#endif
/* GPBR0 is for recording times of entering into backup mode */
gpbr_write(GPBR0, gpbr_read(GPBR0) + 1);
/* Enable the PIO for wake-up */
example_set_wakeup_from_backup_mode();
/* Switch MCK to slow clock */
pmc_switch_mck_to_sclk(PMC_MCKR_PRES_CLK_1);
/* Disable unused clock to save power */
pmc_osc_disable_xtal(0);
example_disable_pll();
/* Enter into backup mode */
pmc_enable_backupmode();
/* Note: The core will reset when exiting from backup mode. */
}
void bm_print_clear(void)
{
usart_enable_tx(BM_USART_USART);
usart_putchar(BM_USART_USART, BM_MSG_START_PATTERN);
usart_putchar(BM_USART_USART, 3 /* length */);
usart_putchar(BM_USART_USART, BM_PRINT_CLEAR);
usart_putchar(BM_USART_USART, BM_MSG_STOP_PATTERN);
while (!usart_is_tx_empty(BM_USART_USART));
usart_disable_tx(BM_USART_USART);
}
void bm_mouse_pointer_ctrl(bool state)
{
usart_enable_tx(BM_USART_USART);
usart_putchar(BM_USART_USART, BM_MSG_START_PATTERN);
usart_putchar(BM_USART_USART, 4 /* length */);
usart_putchar(BM_USART_USART, BM_POINTER_CTRL);
usart_putchar(BM_USART_USART, state);
usart_putchar(BM_USART_USART, BM_MSG_STOP_PATTERN);
while (!usart_is_tx_empty(BM_USART_USART));
usart_disable_tx(BM_USART_USART);
}
static void XPROGTarget_SetRxMode(void)
{
while(usart_is_tx_empty(USART_PDI) == 0);
usart_disable_tx(USART_PDI);
usart_enable_rx(USART_PDI);
gpio_configure_pin(PIN_PDIDTX_GPIO, PIN_PDIDTX_IN_FLAGS);
IsSending = false;
}
void bm_pullup_twi(bool state)
{
usart_enable_tx(BM_USART_USART);
usart_putchar(BM_USART_USART, BM_MSG_START_PATTERN);
usart_putchar(BM_USART_USART, 4 /* length */);
usart_putchar(BM_USART_USART, BM_PULLUP_TWI);
usart_putchar(BM_USART_USART, state);
usart_putchar(BM_USART_USART, BM_MSG_STOP_PATTERN);
while (!usart_is_tx_empty(BM_USART_USART));
usart_disable_tx(BM_USART_USART);
}
void bm_led_tgl(uint32_t led)
{
usart_enable_tx(BM_USART_USART);
usart_putchar(BM_USART_USART, BM_MSG_START_PATTERN);
usart_putchar(BM_USART_USART, 4 /* length */);
usart_putchar(BM_USART_USART, BM_LED_TGL);
usart_putchar(BM_USART_USART, led);
usart_putchar(BM_USART_USART, BM_MSG_STOP_PATTERN);
while (!usart_is_tx_empty(BM_USART_USART));
usart_disable_tx(BM_USART_USART);
}
void bm_mouse_pointer_move(uint32_t x, uint32_t y)
{
usart_enable_tx(BM_USART_USART);
usart_putchar(BM_USART_USART, BM_MSG_START_PATTERN);
usart_putchar(BM_USART_USART, 5 /* length */);
usart_putchar(BM_USART_USART, BM_POINTER_MOVE);
usart_putchar(BM_USART_USART, x);
usart_putchar(BM_USART_USART, y);
usart_putchar(BM_USART_USART, BM_MSG_STOP_PATTERN);
while (!usart_is_tx_empty(BM_USART_USART));
usart_disable_tx(BM_USART_USART);
}
bool bm_get_mcu_current(uint32_t* sleep_mode, float* current)
{
uint32_t current_d;
uint32_t c;
usart_enable_tx(BM_USART_USART);
usart_putchar(BM_USART_USART, BM_MSG_START_PATTERN);
usart_putchar(BM_USART_USART, 4 /* length */);
usart_putchar(BM_USART_USART, BM_MCU_GET_CURRENT);
usart_putchar(BM_USART_USART, *sleep_mode);
usart_putchar(BM_USART_USART, BM_MSG_STOP_PATTERN);
while (!usart_is_tx_empty(BM_USART_USART));
usart_disable_tx(BM_USART_USART);
usart_enable_rx(BM_USART_USART);
// Check first caracter is start pattern
usart_getchar(BM_USART_USART, &c);
if (c == BM_MSG_STOP_PATTERN) {
usart_getchar(BM_USART_USART, &c);
}
if (c != BM_MSG_START_PATTERN) {
return false;
}
// Check second caracter is length
usart_getchar(BM_USART_USART, &c);
if (c != 8) {
return false;
}
// Check third caracter is Current Command
usart_getchar(BM_USART_USART, &c);
if (c != BM_MCU_RET_CURRENT) {
return false;
}
// Check third caracter is sleepmode
usart_getchar(BM_USART_USART, &c);
*sleep_mode = c;
// Then read current
usart_getchar(BM_USART_USART, &c);
current_d = c<<24;
usart_getchar(BM_USART_USART, &c);
current_d |= c<<16;
usart_getchar(BM_USART_USART, &c);
current_d |= c<<8;
usart_getchar(BM_USART_USART, &c);
current_d |= c;
*current = *(float*)& current_d;
// Check last caracter is stop pattern
usart_getchar(BM_USART_USART, &c);
if (c != BM_MSG_STOP_PATTERN) {
return false;
}
usart_disable_rx(BM_USART_USART);
return true;
}
bool bm_get_firmware_version(uint8_t* fw_minor_version, uint8_t* fw_major_version)
{
uint32_t start, length, stop, cmd_id, c;
// Wait for some microseconds in order to avoid fifo overrun
//
delay_ms(20);
usart_enable_tx(BM_USART_USART);
usart_putchar(BM_USART_USART, BM_MSG_START_PATTERN);
usart_putchar(BM_USART_USART, 3 /* length */);
usart_putchar(BM_USART_USART, BM_GET_FIRMWARE_VERSION);
usart_putchar(BM_USART_USART, BM_MSG_STOP_PATTERN);
while (!usart_is_tx_empty(BM_USART_USART));
usart_disable_tx(BM_USART_USART);
usart_enable_rx(BM_USART_USART);
// Check first character is start pattern
usart_getchar(BM_USART_USART, &start);
if (start == BM_MSG_STOP_PATTERN) {
usart_getchar(BM_USART_USART, &start);
}
if (start != BM_MSG_START_PATTERN) {
return false;
}
// Check second character is length
usart_getchar(BM_USART_USART, &length);
if (length != 5) {
return false;
}
// Check third character is Current Command
usart_getchar(BM_USART_USART, &cmd_id);
if (cmd_id != BM_RET_FIRMWARE_VERSION) {
return false;
}
// Get Fifo free size
usart_getchar(BM_USART_USART, &c);
*fw_major_version = c;
usart_getchar(BM_USART_USART, &c);
*fw_minor_version = c;
// Check last character is stop pattern
usart_getchar(BM_USART_USART, &stop);
if (stop != BM_MSG_STOP_PATTERN) {
return false;
}
usart_disable_rx(BM_USART_USART);
return true;
}
bool bm_get_fifo_free_size(uint16_t* free_size)
{
uint32_t start, length, stop, cmd_id, c;
// Wait for some microseconds in order to avoid fifo overrun
//
delay_ms(20);
usart_enable_tx(BM_USART_USART);
usart_putchar(BM_USART_USART, BM_MSG_START_PATTERN);
usart_putchar(BM_USART_USART, 3 /* length */);
usart_putchar(BM_USART_USART, BM_MCU_GET_FIFO_FREE_SIZE);
usart_putchar(BM_USART_USART, BM_MSG_STOP_PATTERN);
while (!usart_is_tx_empty(BM_USART_USART));
usart_disable_tx(BM_USART_USART);
usart_enable_rx(BM_USART_USART);
// Check first character is start pattern
usart_getchar(BM_USART_USART, &start);
if (start == BM_MSG_STOP_PATTERN) {
usart_getchar(BM_USART_USART, &start);
}
if (start != BM_MSG_START_PATTERN) {
return false;
}
// Check second character is length
usart_getchar(BM_USART_USART, &length);
if (length != 5) {
return false;
}
// Check third character is Current Command
usart_getchar(BM_USART_USART, &cmd_id);
if (cmd_id != BM_MCU_RET_FIFO_FREE_SIZE) {
return false;
}
// Get Fifo free size
usart_getchar(BM_USART_USART, &c);
*free_size = c << 8;
usart_getchar(BM_USART_USART, &c);
*free_size |= c;
// Check last character is stop pattern
usart_getchar(BM_USART_USART, &stop);
if (stop != BM_MSG_STOP_PATTERN) {
return false;
}
usart_disable_rx(BM_USART_USART);
return true;
}
void bm_tgl_button(uint32_t timeout_ms)
{
usart_enable_tx(BM_USART_USART);
usart_putchar(BM_USART_USART, BM_MSG_START_PATTERN);
usart_putchar(BM_USART_USART, 7 /* length */);
usart_putchar(BM_USART_USART, BM_TGL_BUTTON);
usart_putchar(BM_USART_USART, timeout_ms & 0xff);
usart_putchar(BM_USART_USART, (timeout_ms >> 8 ) & 0xff);
usart_putchar(BM_USART_USART, (timeout_ms >> 16) & 0xff);
usart_putchar(BM_USART_USART, timeout_ms >> 24);
usart_putchar(BM_USART_USART, BM_MSG_STOP_PATTERN);
while (!usart_is_tx_empty(BM_USART_USART));
usart_disable_tx(BM_USART_USART);
}
void bm_send_picouart_frame(uint8_t frame, uint32_t timeout_ms)
{
usart_enable_tx(BM_USART_USART);
usart_putchar(BM_USART_USART, BM_MSG_START_PATTERN);
usart_putchar(BM_USART_USART, 8 /* length */);
usart_putchar(BM_USART_USART, BM_PICOUART_SEND);
usart_putchar(BM_USART_USART, frame);
usart_putchar(BM_USART_USART, timeout_ms & 0xff);
usart_putchar(BM_USART_USART, (timeout_ms >> 8 ) & 0xff);
usart_putchar(BM_USART_USART, (timeout_ms >> 16) & 0xff);
usart_putchar(BM_USART_USART, timeout_ms >> 24);
usart_putchar(BM_USART_USART, BM_MSG_STOP_PATTERN);
while (!usart_is_tx_empty(BM_USART_USART));
usart_disable_tx(BM_USART_USART);
}
void bm_send_mcu_status(uint32_t power_scaling, uint32_t sleep_mode,
uint32_t cpu_freq, uint32_t cpu_src)
{
usart_enable_tx(BM_USART_USART);
usart_putchar(BM_USART_USART, BM_MSG_START_PATTERN);
usart_putchar(BM_USART_USART, 10 /* length */);
usart_putchar(BM_USART_USART, BM_MCU_STATUS);
usart_putchar(BM_USART_USART, power_scaling);
usart_putchar(BM_USART_USART, sleep_mode);
usart_putchar(BM_USART_USART, cpu_freq >> 24);
usart_putchar(BM_USART_USART, (cpu_freq >> 16) & 0xff);
usart_putchar(BM_USART_USART, (cpu_freq >> 8 ) & 0xff);
usart_putchar(BM_USART_USART, cpu_freq & 0xff);
usart_putchar(BM_USART_USART, cpu_src);
usart_putchar(BM_USART_USART, BM_MSG_STOP_PATTERN);
while (!usart_is_tx_empty(BM_USART_USART));
usart_disable_tx(BM_USART_USART);
}
/**
* \brief transmit data.
*
* \param *p_buff data to be transmitted
* \param ulsize size of all data.
*
*/
uint8_t func_transmit(const uint8_t *p_buff, uint32_t ulsize)
{
Assert(p_buff);
while(ulsize > 0) {
if(0 == usart_write(BOARD_USART, *p_buff)){
usart_enable_interrupt(BOARD_USART, US_IER_TXRDY | US_IER_TXEMPTY);
ulsize--;
p_buff++;
}
}
while(!usart_is_tx_empty(BOARD_USART)) {
; /*waiting for transmit over*/
}
return 0;
}
/**
* \brief Test wait mode.
*/
static void test_wait_mode(void)
{
puts(STRING_WAIT);
#if SAMG55
/* Wait for the transmission done before changing clock */
while (!usart_is_tx_empty(CONSOLE_UART)) {
}
#else
/* Wait for the transmission done before changing clock */
while (!uart_is_tx_empty(CONSOLE_UART)) {
}
#endif
/* Configure fast RC oscillator */
pmc_switch_mck_to_sclk(PMC_MCKR_PRES_CLK_1);
#if (SAMG)
pmc_switch_mainck_to_fastrc(CKGR_MOR_MOSCRCF_8_MHz);
#else
pmc_switch_mainck_to_fastrc(CKGR_MOR_MOSCRCF_4_MHz);
#endif
pmc_switch_mck_to_mainck(PMC_PCK_PRES_CLK_1);
#if (SAMG)
g_ul_current_mck = 8000000; /* 8MHz */
#else
g_ul_current_mck = 4000000; /* 4MHz */
#endif
/* Disable unused clock to save power */
pmc_osc_disable_xtal(0);
example_disable_pll();
/* Set wakeup input for fast startup */
example_set_wakeup_from_wait_mode();
/* Enter into wait Mode */
pmc_enable_waitmode();
/* Set default clock and re-configure UART */
set_default_working_clock();
reconfigure_console(g_ul_current_mck, CONF_UART_BAUDRATE);
puts("Exit from wait Mode.\r");
}
/**
* \brief transmit data in synchronous mode.
*
* \param *p_buff data to be transmitted
* \param ulsize size of all data.
*
*/
static uint8_t transmit_mode_sync(uint8_t *p_buff, uint32_t ulsize)
{
Assert(p_buff);
while(ulsize > 0) {
if(0 == usart_write(BOARD_USART, *p_buff)){
usart_enable_interrupt(BOARD_USART, US_IER_TXRDY | US_IER_TXEMPTY);
ulsize--;
p_buff++;
}
}
while(!usart_is_tx_empty(BOARD_USART)) {
; /*waiting for transmit over*/
}
g_ul_sent_done = true;
return 0;
}
/**
* \brief Initialize the chip for low power test.
*/
static void init_chip(void)
{
#if SAMG55
/* Wait for the transmission done before changing clock */
while (!usart_is_tx_empty(CONSOLE_UART)) {
}
#else
/* Wait for the transmission done before changing clock */
while (!uart_is_tx_empty(CONSOLE_UART)) {
}
#endif
/* Disable all the peripheral clocks */
pmc_disable_all_periph_clk();
/* Disable brownout detector */
supc_disable_brownout_detector(SUPC);
/* Initialize the specific board */
init_specific_board();
}
void bm_print_txt(uint8_t* str, uint8_t str_length)
{
#define BM_PRINT_TEXT_SIZE 21
#define BM_PRINT_TEXT_DEEP 6
usart_enable_tx(BM_USART_USART);
usart_putchar(BM_USART_USART, BM_MSG_START_PATTERN);
usart_putchar(BM_USART_USART, BM_PRINT_TEXT_SIZE + 3 /* length */);
usart_putchar(BM_USART_USART, BM_PRINT_TEXT);
if (str_length < BM_PRINT_TEXT_SIZE) {
for (uint8_t i=0;i<str_length;i++){
usart_putchar(BM_USART_USART, str[i]);
}
for (uint8_t i=0;i < BM_PRINT_TEXT_SIZE - str_length;i++){
usart_putchar(BM_USART_USART, '\0');
}
} else {
for (uint8_t i=0;i<BM_PRINT_TEXT_SIZE;i++){
usart_putchar(BM_USART_USART, str[i]);
}
}
usart_putchar(BM_USART_USART, BM_MSG_STOP_PATTERN);
while (!usart_is_tx_empty(BM_USART_USART));
usart_disable_tx(BM_USART_USART);
}
/*! \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(Usart *p_usart)
{
return usart_is_tx_empty(p_usart);
}
/**
* \brief Change clock configuration.
*
* \param p_uc_str Hint string to be output on console before changing clock.
*/
static void user_change_clock(uint8_t *p_uc_str)
{
uint8_t uc_key;
uint32_t ul_id;
/* Print menu */
puts(CLOCK_LIST_MENU);
scanf("%c", (char *)&uc_key);
printf("Select option is: %c\n\r\n\r", uc_key);
if (p_uc_str) {
puts((char const *)p_uc_str);
}
#if SAMG55
/* Wait for the transmission done before changing clock */
while (!usart_is_tx_empty(CONSOLE_UART)) {
}
#else
/* Wait for the transmission done before changing clock */
while (!uart_is_tx_empty(CONSOLE_UART)) {
}
#endif
if ((uc_key >= MIN_CLOCK_FAST_RC_ITEM) &&
(uc_key <= MAX_CLOCK_FAST_RC_ITEM)) {
ul_id = uc_key - MIN_CLOCK_FAST_RC_ITEM;
/* Save current clock */
g_ul_current_mck = g_fastrc_clock_list[ul_id][0];
/* Switch MCK to Slow clock */
pmc_switch_mck_to_sclk(PMC_MCKR_PRES_CLK_1);
/* Switch mainck to fast RC */
pmc_osc_enable_fastrc(CKGR_MOR_MOSCRCF_8_MHz);
pmc_switch_mainck_to_fastrc(g_fastrc_clock_list[ul_id][1]);
/* Switch MCK to mainck */
pmc_switch_mck_to_mainck(g_fastrc_clock_list[ul_id][2]);
/* Disable unused clock to save power */
pmc_osc_disable_xtal(0);
example_disable_pll();
} else if ((uc_key >= MIN_CLOCK_PLL_ITEM) &&
(uc_key <= MAX_CLOCK_PLL_ITEM)) {
ul_id = uc_key - MIN_CLOCK_PLL_ITEM;
/* Save current clock */
g_ul_current_mck = g_pll_clock_list[ul_id][0];
#if (SAMG)
/* Switch MCK to main clock */
pmc_switch_mck_to_mainck(PMC_MCKR_PRES_CLK_1);
#else
/* Switch MCK to slow clock */
pmc_switch_mck_to_sclk(PMC_MCKR_PRES_CLK_1);
/* Switch mainck to external xtal */
pmc_switch_mainck_to_xtal(0, BOARD_OSC_STARTUP_US);
#endif
/* Configure PLL and switch clock */
example_switch_clock(g_pll_clock_list[ul_id][1], PLL_COUNT,
g_pll_clock_list[ul_id][2], g_pll_clock_list[ul_id][3]);
#if (!SAMG)
/* Disable unused clock to save power */
pmc_osc_disable_fastrc();
#endif
} else {
puts("Clock is not changed.\r");
}
}
/**
* \brief Wait until test assert is done (no wave on assert port)
*/
static inline void wait_test_assert_idle(void)
{
while(!usart_is_tx_empty(CONF_TEST_USART));
}