自学教程：C++ usart_get_config_defaults函数代码示例

/** * /brief Configure UART console. */static void configure_console(void){#if SAMD21	struct usart_config usart_conf;	usart_get_config_defaults(&usart_conf);	usart_conf.mux_setting = CONF_STDIO_MUX_SETTING;	usart_conf.pinmux_pad0 = CONF_STDIO_PINMUX_PAD0;	usart_conf.pinmux_pad1 = CONF_STDIO_PINMUX_PAD1;	usart_conf.pinmux_pad2 = CONF_STDIO_PINMUX_PAD2;	usart_conf.pinmux_pad3 = CONF_STDIO_PINMUX_PAD3;	usart_conf.baudrate    = CONF_STDIO_BAUDRATE;	stdio_serial_init(&cdc_uart_module, CONF_STDIO_USART_MODULE, &usart_conf);	usart_enable(&cdc_uart_module);#elif SAME70	const usart_serial_options_t uart_serial_options = {		.baudrate = CONF_UART_BAUDRATE,#ifdef CONF_UART_CHAR_LENGTH		.charlength = CONF_UART_CHAR_LENGTH,#endif		.paritytype = CONF_UART_PARITY,#ifdef CONF_UART_STOP_BITS		.stopbits = CONF_UART_STOP_BITS,#endif	};	/* Configure console UART. */	sysclk_enable_peripheral_clock(CONSOLE_UART_ID);	stdio_serial_init(CONF_UART, &uart_serial_options);#endif}

/* === IMPLEMENTATION ====================================================== */static inline void usart_configure_flowcontrol(void){	struct usart_config config_usart;#if UART_FLOWCONTROL_6WIRE_MODE == true	usart_disable(&usart_instance);	usart_reset(&usart_instance);#endif	usart_get_config_defaults(&config_usart);	config_usart.baudrate = CONF_FLCR_BLE_BAUDRATE;	config_usart.generator_source = CONF_FLCR_BLE_UART_CLOCK;	config_usart.mux_setting = CONF_FLCR_BLE_MUX_SETTING;	config_usart.pinmux_pad0 = CONF_FLCR_BLE_PINMUX_PAD0;	config_usart.pinmux_pad1 = CONF_FLCR_BLE_PINMUX_PAD1;	config_usart.pinmux_pad2 = CONF_FLCR_BLE_PINMUX_PAD2;	config_usart.pinmux_pad3 = CONF_FLCR_BLE_PINMUX_PAD3;	while (usart_init(&usart_instance, CONF_FLCR_BLE_USART_MODULE, &config_usart) != STATUS_OK);	usart_enable(&usart_instance);		/* register and enable usart callbacks */	usart_register_callback(&usart_instance,	serial_drv_read_cb, USART_CALLBACK_BUFFER_RECEIVED);	usart_register_callback(&usart_instance,	serial_drv_write_cb, USART_CALLBACK_BUFFER_TRANSMITTED);	usart_enable_callback(&usart_instance, USART_CALLBACK_BUFFER_RECEIVED);	usart_enable_callback(&usart_instance, USART_CALLBACK_BUFFER_TRANSMITTED);	serial_read_byte(&rx_data);}

//Sets USART to the EDBG virtual COM port of SAMD21 Xprovoid configure_usart(void){		struct usart_config config_usart;	usart_get_config_defaults(&config_usart);		config_usart.baudrate    = 9600; //Need to find the SERCOM/pins connected to EDBG on the SAMW25	/*	config_usart.mux_setting = EDBG_CDC_SERCOM_MUX_SETTING; //USART_RX_1_TX_0_XCK_1	config_usart.pinmux_pad0 = EDBG_CDC_SERCOM_PINMUX_PAD0; //PINMUX_PA22C_SERCOM3_PAD0	config_usart.pinmux_pad1 = EDBG_CDC_SERCOM_PINMUX_PAD1; //PINMUX_PA23C_SERCOM3_PAD1	config_usart.pinmux_pad2 = EDBG_CDC_SERCOM_PINMUX_PAD2; //PINMUX_UNUSED	config_usart.pinmux_pad3 = EDBG_CDC_SERCOM_PINMUX_PAD3; //PINMUX_UNUSED		while (usart_init(&usart_instance,	EDBG_CDC_MODULE, &config_usart) != STATUS_OK) {}	*/		config_usart.mux_setting = USART_RX_1_TX_0_XCK_1; //USART_RX_1_TX_2_XCK_3	config_usart.pinmux_pad0 = PINMUX_PA12C_SERCOM2_PAD0;	config_usart.pinmux_pad1 = PINMUX_PA13C_SERCOM2_PAD1;	config_usart.pinmux_pad2 = PINMUX_UNUSED;	config_usart.pinmux_pad3 = PINMUX_UNUSED;		while(usart_init(&usart_instance,SERCOM2, &config_usart) != STATUS_OK) {}		usart_enable(&usart_instance);}

/** * /brief configure and enable SERCOM - USART */void configure_usart(void){	/* USART set up configuration */	struct usart_config config_usart;		/* USART base address */	SercomUsart *const usart_hw	= SERCOM2;		/* Get USART default configuration */	usart_get_config_defaults(&config_usart);	/* Configure USART baud rate and pad */	config_usart.baudrate    = 460800;	config_usart.mux_setting = EDBG_CDC_SERCOM_MUX_SETTING;	config_usart.pinmux_pad0 = EDBG_CDC_SERCOM_PINMUX_PAD0;	config_usart.pinmux_pad1 = EDBG_CDC_SERCOM_PINMUX_PAD1;	config_usart.pinmux_pad2 = EDBG_CDC_SERCOM_PINMUX_PAD2;	config_usart.pinmux_pad3 = EDBG_CDC_SERCOM_PINMUX_PAD3;	/* Initialize USART */	while (usart_init(&usart_instance,	EDBG_CDC_MODULE, &config_usart) != STATUS_OK) {	}	/* Enable USART */	usart_enable(&usart_instance);		/* Enable USART transfer complete interrupt */	usart_hw->INTENSET.reg	= SERCOM_USART_INTFLAG_TXC;}

otError otPlatUartEnable(void){    struct usart_config configUsart;    usart_get_config_defaults(&configUsart);    configUsart.baudrate    = 115200;    configUsart.mux_setting = UART_SERCOM_MUX_SETTING;    configUsart.pinmux_pad0 = UART_SERCOM_PINMUX_PAD0;    configUsart.pinmux_pad1 = UART_SERCOM_PINMUX_PAD1;    configUsart.pinmux_pad2 = UART_SERCOM_PINMUX_PAD2;    configUsart.pinmux_pad3 = UART_SERCOM_PINMUX_PAD3;    while (usart_init(&sUsartInstance, UART_SERCOM_MODULE, &configUsart) != STATUS_OK)        ;    usart_enable(&sUsartInstance);    sReceive.mHead = 0;    sReceive.mTail = 0;    usart_register_callback(&sUsartInstance, usartWriteCallback, USART_CALLBACK_BUFFER_TRANSMITTED);    usart_register_callback(&sUsartInstance, usartReadCallback, USART_CALLBACK_BUFFER_RECEIVED);    usart_enable_callback(&sUsartInstance, USART_CALLBACK_BUFFER_TRANSMITTED);    usart_enable_callback(&sUsartInstance, USART_CALLBACK_BUFFER_RECEIVED);    usart_read_job(&sUsartInstance, (uint16_t *)&sReceive.mBuffer[sReceive.mTail]);    return OT_ERROR_NONE;}

/*---------------------------------------------------------------------------*/static intopen(int32_t baudrate, uart_rx_char_callback char_cb, uart_rx_frame_callback frame_cb){  struct usart_config config_usart;  struct port_config pin_conf;  usart_get_config_defaults(&config_usart);  config_usart.baudrate    = baudrate;  config_usart.mux_setting = RS485_SERCOM_MUX_SETTING;  config_usart.pinmux_pad0 = RS485_SERCOM_PINMUX_PAD0;  config_usart.pinmux_pad1 = RS485_SERCOM_PINMUX_PAD1;  config_usart.pinmux_pad2 = RS485_SERCOM_PINMUX_PAD2;  config_usart.pinmux_pad3 = RS485_SERCOM_PINMUX_PAD3;  while (usart_init(&usart_instance, RS485_MODULE, &config_usart) != STATUS_OK) {}  usart_enable(&usart_instance);  port_get_config_defaults(&pin_conf);  pin_conf.direction = PORT_PIN_DIR_OUTPUT;  port_pin_set_config(RS485_TXE, &pin_conf);  port_pin_set_output_level(RS485_TXE, false);  char_callback = char_cb;  usart_register_callback(&usart_instance,                          usart_read_callback, USART_CALLBACK_BUFFER_RECEIVED);  usart_enable_callback(&usart_instance, USART_CALLBACK_BUFFER_RECEIVED);  usart_read_job(&usart_instance, &rx_char);  return 1;}

uint8_t configure_serial_drv(void){	#if UART_FLOWCONTROL_4WIRE_MODE == true		usart_configure_flowcontrol();		#warning "This mode works only if Flow Control Permanently Enabled in the BTLC1000"	#else	struct usart_config config_usart;	usart_get_config_defaults(&config_usart);	config_usart.baudrate = CONF_BLE_BAUDRATE;	config_usart.generator_source = CONF_BLE_UART_CLOCK;	config_usart.mux_setting = CONF_BLE_MUX_SETTING;	config_usart.pinmux_pad0 = CONF_BLE_PINMUX_PAD0;	config_usart.pinmux_pad1 = CONF_BLE_PINMUX_PAD1;	config_usart.pinmux_pad2 = CONF_BLE_PINMUX_PAD2;	config_usart.pinmux_pad3 = CONF_BLE_PINMUX_PAD3;	while (usart_init(&usart_instance, CONF_BLE_USART_MODULE, &config_usart) != STATUS_OK);	usart_enable(&usart_instance);		/* register and enable usart callbacks */	usart_register_callback(&usart_instance,		serial_drv_read_cb, USART_CALLBACK_BUFFER_RECEIVED);	usart_register_callback(&usart_instance,		serial_drv_write_cb, USART_CALLBACK_BUFFER_TRANSMITTED);	usart_enable_callback(&usart_instance, USART_CALLBACK_BUFFER_RECEIVED);	usart_enable_callback(&usart_instance, USART_CALLBACK_BUFFER_TRANSMITTED);	serial_read_byte(&rx_data);	#endif		return STATUS_OK;}

void configure_console(void){	struct usart_config usart_conf;	usart_get_config_defaults(&usart_conf);	usart_conf.mux_setting = EDBG_CDC_SERCOM_MUX_SETTING;	usart_conf.pinmux_pad0 = EDBG_CDC_SERCOM_PINMUX_PAD0;	usart_conf.pinmux_pad1 = EDBG_CDC_SERCOM_PINMUX_PAD1;	usart_conf.pinmux_pad2 = EDBG_CDC_SERCOM_PINMUX_PAD2;	usart_conf.pinmux_pad3 = EDBG_CDC_SERCOM_PINMUX_PAD3;	usart_conf.baudrate    = 115200;	stdio_serial_init(&cdc_uart_module, EDBG_CDC_MODULE, &usart_conf);	usart_enable(&cdc_uart_module);}

/*** /brief Configure serial console.*/static void configure_console(void){    struct usart_config config_usart;    usart_get_config_defaults(&config_usart);    config_usart.baudrate    = 115200;    config_usart.mux_setting = EDBG_CDC_SERCOM_MUX_SETTING;    config_usart.pinmux_pad0 = EDBG_CDC_SERCOM_PINMUX_PAD0;    config_usart.pinmux_pad1 = EDBG_CDC_SERCOM_PINMUX_PAD1;    config_usart.pinmux_pad2 = EDBG_CDC_SERCOM_PINMUX_PAD2;    config_usart.pinmux_pad3 = EDBG_CDC_SERCOM_PINMUX_PAD3;    stdio_serial_init(&usart_instance, EDBG_CDC_MODULE, &config_usart);    usart_enable(&usart_instance);}

// Configure SERCOM channel 1 as USART for BLE modulevoid configure_usart(void){	struct usart_config config_usart;	usart_get_config_defaults(&config_usart);	config_usart.baudrate    = 9600;	config_usart.mux_setting = USART_RX_3_TX_2_XCK_3;	config_usart.pinmux_pad0 = PINMUX_UNUSED;	config_usart.pinmux_pad1 = PINMUX_UNUSED;	config_usart.pinmux_pad2 = PINMUX_PA18C_SERCOM1_PAD2;	config_usart.pinmux_pad3 = PINMUX_PA19C_SERCOM1_PAD3;	while (usart_init(&usart_instance,SERCOM1, &config_usart) != STATUS_OK) 	{}	usart_enable(&usart_instance);}

/** *  Configure UART console. */static void configure_console(void){    struct usart_config usart_conf;    usart_get_config_defaults(&usart_conf);    usart_conf.mux_setting = CONF_STDIO_MUX_SETTING;    usart_conf.pinmux_pad0 = CONF_STDIO_PINMUX_PAD0;    usart_conf.pinmux_pad1 = CONF_STDIO_PINMUX_PAD1;    usart_conf.pinmux_pad2 = CONF_STDIO_PINMUX_PAD2;    usart_conf.pinmux_pad3 = CONF_STDIO_PINMUX_PAD3;    usart_conf.baudrate    = CONF_STDIO_BAUDRATE;    stdio_serial_init(&cdc_uart_module, CONF_STDIO_USART_MODULE, &usart_conf);}

static void configure_console(void){	struct usart_config usart_conf;	usart_get_config_defaults(&usart_conf);	usart_conf.mux_setting = HOST_SERCOM_MUX_SETTING;	usart_conf.pinmux_pad0 = HOST_SERCOM_PINMUX_PAD0;	usart_conf.pinmux_pad1 = HOST_SERCOM_PINMUX_PAD1;	usart_conf.pinmux_pad2 = HOST_SERCOM_PINMUX_PAD2;	usart_conf.pinmux_pad3 = HOST_SERCOM_PINMUX_PAD3;	usart_conf.baudrate    = USART_HOST_BAUDRATE;	stdio_serial_init(&cdc_uart_module, USART_HOST, &usart_conf);	usart_enable(&cdc_uart_module);}

/** Set up the USART (EDBG) communication for debug purpose. */static void setup_usart_channel(void){	struct usart_config config_usart;	usart_get_config_defaults(&config_usart);	/* Configure the USART settings and initialize the standard I/O library */	config_usart.baudrate = 115200;	config_usart.mux_setting = EDBG_CDC_SERCOM_MUX_SETTING;	config_usart.pinmux_pad0 = EDBG_CDC_SERCOM_PINMUX_PAD0;	config_usart.pinmux_pad1 = EDBG_CDC_SERCOM_PINMUX_PAD1;	config_usart.pinmux_pad2 = EDBG_CDC_SERCOM_PINMUX_PAD2;	config_usart.pinmux_pad3 = EDBG_CDC_SERCOM_PINMUX_PAD3;	stdio_serial_init(&usart_instance, EDBG_CDC_MODULE, &config_usart);	usart_enable(&usart_instance);}

static void serial_port_init(void){	struct usart_config usart_conf;	/* Configure USART for unit test output */	usart_get_config_defaults(&usart_conf);	usart_conf.mux_setting = EDBG_CDC_SERCOM_MUX_SETTING;	usart_conf.pinmux_pad0 = EDBG_CDC_SERCOM_PINMUX_PAD0;	usart_conf.pinmux_pad1 = EDBG_CDC_SERCOM_PINMUX_PAD1;	usart_conf.pinmux_pad2 = EDBG_CDC_SERCOM_PINMUX_PAD2;	usart_conf.pinmux_pad3 = EDBG_CDC_SERCOM_PINMUX_PAD3;	usart_conf.baudrate    = DEFAULT_BAUD_RATE;	stdio_serial_init(&usart_instance, EDBG_CDC_MODULE, &usart_conf);	usart_enable(&usart_instance);}

/** * /brief Initialize the USART for unit test * * Initializes the SERCOM USART used for sending the unit test status to the * computer via the EDBG CDC gateway. */static void cdc_uart_init(void){	struct usart_config usart_conf;	/* Configure USART for unit test output */	usart_get_config_defaults(&usart_conf);	usart_conf.mux_setting = CONF_STDIO_MUX_SETTING;	usart_conf.pinmux_pad0 = CONF_STDIO_PINMUX_PAD0;	usart_conf.pinmux_pad1 = CONF_STDIO_PINMUX_PAD1;	usart_conf.pinmux_pad2 = CONF_STDIO_PINMUX_PAD2;	usart_conf.pinmux_pad3 = CONF_STDIO_PINMUX_PAD3;	usart_conf.baudrate    = CONF_STDIO_BAUDRATE;	stdio_serial_init(&cdc_uart_module, CONF_STDIO_USART, &usart_conf);	usart_enable(&cdc_uart_module);}

struct usart_module * cph_stdio_init(void) {	struct usart_config config_usart;	usart_get_config_defaults(&config_usart);	config_usart.baudrate = STDIO_BAUD;	config_usart.mux_setting = STDIO_MUX;	config_usart.pinmux_pad0 = STDIO_PAD0;	config_usart.pinmux_pad1 = STDIO_PAD1;	config_usart.pinmux_pad2 = STDIO_PAD2;	config_usart.pinmux_pad3 = STDIO_PAD3;	stdio_serial_init(&usart_instance, STDIO_HW, &config_usart);	usart_enable(&usart_instance);	return &usart_instance;}

/*! * /brief Initialize USART to communicate with on board EDBG - SERCOM  * with the following settings. * - 8-bit asynchronous USART * - No parity * - One stop bit * - 115200 baud */ static void configure_usart(void){	struct usart_config config_usart;	// Get the default USART configuration	usart_get_config_defaults(&config_usart);	// Configure the baudrate	config_usart.baudrate = 115200;	// Configure the pin multiplexing for USART	config_usart.mux_setting = EDBG_CDC_SERCOM_MUX_SETTING;	config_usart.pinmux_pad0 = EDBG_CDC_SERCOM_PINMUX_PAD0;	config_usart.pinmux_pad1 = EDBG_CDC_SERCOM_PINMUX_PAD1;	config_usart.pinmux_pad2 = EDBG_CDC_SERCOM_PINMUX_PAD2;	config_usart.pinmux_pad3 = EDBG_CDC_SERCOM_PINMUX_PAD3;	// route the printf output to the USART	stdio_serial_init(&usart_instance, EDBG_CDC_MODULE, &config_usart);	// enable USART	usart_enable(&usart_instance);}

void usart_configureBluetooth( void ){    struct usart_config bluetooth_config;        usart_get_config_defaults(&bluetooth_config);        bluetooth_config.baudrate       = BAUDRATE_BLUETOOTH;    bluetooth_config.mux_setting    = BT_USART_SERCOM_MUX_SETTING;    bluetooth_config.pinmux_pad0    = BT_USART_SERCOM_PINMUX_PAD0;    bluetooth_config.pinmux_pad1    = BT_USART_SERCOM_PINMUX_PAD1;    bluetooth_config.pinmux_pad2    = BT_USART_SERCOM_PINMUX_PAD2;    bluetooth_config.pinmux_pad3    = BT_USART_SERCOM_PINMUX_PAD3;        while ( usart_init(&usart_instanceBluetooth,            BT_USART_MODULE, &bluetooth_config) != STATUS_OK );        usart_enable(&usart_instanceBluetooth);}

static void configure_usart(const struct UsartConfig * config){    struct usart_config config_usart;        usart_get_config_defaults(&config_usart);    config_usart.baudrate    = config->baudrate;    config_usart.mux_setting = config->mux_setting;    config_usart.pinmux_pad0 = config->pinmux_pad0;    config_usart.pinmux_pad1 = config->pinmux_pad1;    config_usart.pinmux_pad2 = config->pinmux_pad2;    config_usart.pinmux_pad3 = config->pinmux_pad3;    while (usart_init(&usart_debug, config->module, &config_usart) != STATUS_OK) {    }    stdio_serial_init(&usart_debug, config->module, &config_usart);    usart_enable(&usart_debug);}

void usart_configureFTDI( void ){    struct usart_config FTDI_config;        usart_get_config_defaults(&FTDI_config);        FTDI_config.baudrate    = BAUDRATE_FTDI;    FTDI_config.mux_setting = FTDI_USART_SERCOM_MUX_SETTING;    FTDI_config.pinmux_pad0 = FTDI_USART_SERCOM_PINMUX_PAD0;    FTDI_config.pinmux_pad1 = FTDI_USART_SERCOM_PINMUX_PAD1;    FTDI_config.pinmux_pad2 = FTDI_USART_SERCOM_PINMUX_PAD2;    FTDI_config.pinmux_pad3 = FTDI_USART_SERCOM_PINMUX_PAD3;        while ( usart_init(&usart_instanceFTDI,            FTDI_USART_MODULE, &FTDI_config) != STATUS_OK );        usart_enable(&usart_instanceFTDI);    }

void configure_console(void){		struct usart_config conf_usart;		usart_get_config_defaults(&conf_usart);		conf_usart.generator_source = GCLK_GENERATOR_1;	conf_usart.baudrate = 9600;	conf_usart.mux_setting = EDBG_CDC_SERCOM_MUX_SETTING;		conf_usart.pinmux_pad0 = EDBG_CDC_SERCOM_PINMUX_PAD0;	conf_usart.pinmux_pad1 = EDBG_CDC_SERCOM_PINMUX_PAD1;	conf_usart.pinmux_pad2 = EDBG_CDC_SERCOM_PINMUX_PAD2;	conf_usart.pinmux_pad3 = EDBG_CDC_SERCOM_PINMUX_PAD3;		stdio_serial_init(&console_instance, EDBG_CDC_MODULE, &conf_usart);		usart_enable(&console_instance);}

/*---------------------------------------------------------------------------*/static void _hal_usartInit( void ){    /* USART configured as follow:     - BaudRate = 34800 baud     - Word Length = 8 Bits     - ONE Stop Bit     - NO parity     - Hardware flow control disabled (RTS and CTS signals)     - Receive and transmit enabled     *///! [setup_config]    struct usart_config config_usart;//! [setup_config]//! [setup_config_defaults]    usart_get_config_defaults( &config_usart );//! [setup_config_defaults]//! [setup_change_config]    config_usart.baudrate = SAMD21_USART0_BAUDRATE;    config_usart.mux_setting = SAMD21_USART0_SERCOM_MUX_SETTING;    config_usart.pinmux_pad0 = SAMD21_USART0_SERCOM_PMUX0;    config_usart.pinmux_pad1 = SAMD21_USART0_SERCOM_PMUX1;    config_usart.pinmux_pad2 = SAMD21_USART0_SERCOM_PMUX2;    config_usart.pinmux_pad3 = SAMD21_USART0_SERCOM_PMUX3;//! [setup_change_config]//! [setup_set_config]    while( usart_init( &st_usartInst, SAMD21_USART0_SERCOM, &config_usart )            != STATUS_OK )    {    }//! [setup_set_config]//! [setup_enable]    usart_enable( &st_usartInst );//! [setup_enable]// Initialize Serial Interface using Stdio Library    stdio_serial_init( &st_usartInst, SAMD21_USART0_SERCOM, &config_usart );    //stdout = &st_usartStdout;} /* _hal_usartInit() */

static void prvConfigureUART( struct usart_module *pxCDCUsart ){struct usart_config xUARTConfig;	/* This semaphore is used to allow the task to wait for the Tx to complete	without wasting any CPU time. */	vSemaphoreCreateBinary( xTxCompleteSemaphore );	configASSERT( xTxCompleteSemaphore );		/* This semaphore is used to allow the task to block for an Rx to complete	without wasting any CPU time. */	vSemaphoreCreateBinary( xRxCompleteSemaphore );	configASSERT( xRxCompleteSemaphore );	/* Take the semaphores so they start in the wanted state.  A block time is	not necessary, and is therefore set to 0, as it is known that the semaphores	exists - they have just been created. */	xSemaphoreTake( xTxCompleteSemaphore, 0 );	xSemaphoreTake( xRxCompleteSemaphore, 0 );	/* Configure the hardware. */	usart_get_config_defaults( &xUARTConfig );	xUARTConfig.baudrate    = 115200;	xUARTConfig.mux_setting = EDBG_CDC_SERCOM_MUX_SETTING;	xUARTConfig.pinmux_pad0 = EDBG_CDC_SERCOM_PINMUX_PAD0;	xUARTConfig.pinmux_pad1 = EDBG_CDC_SERCOM_PINMUX_PAD1;	xUARTConfig.pinmux_pad2 = EDBG_CDC_SERCOM_PINMUX_PAD2;	xUARTConfig.pinmux_pad3 = EDBG_CDC_SERCOM_PINMUX_PAD3;	while( usart_init( pxCDCUsart, EDBG_CDC_MODULE, &xUARTConfig ) != STATUS_OK ) 	{		/* Nothing to do here.  Should include a timeout really but this is		init code only. */	}	usart_enable( pxCDCUsart );		/* Register the driver callbacks. */	usart_register_callback( pxCDCUsart, prvUARTTxNotificationHandler, USART_CALLBACK_BUFFER_TRANSMITTED );	usart_register_callback( pxCDCUsart, prvUARTRxNotificationHandler, USART_CALLBACK_BUFFER_RECEIVED );	usart_enable_callback( pxCDCUsart, USART_CALLBACK_BUFFER_TRANSMITTED );	usart_enable_callback( pxCDCUsart, USART_CALLBACK_BUFFER_RECEIVED );}

bool COZIR_WV_100_init(void){	struct usart_config usart_conf;		usart_get_config_defaults(&usart_conf);	usart_conf.mux_setting = USART_RX_3_TX_2_XCK_3;	usart_conf.pinmux_pad0 = PINMUX_UNUSED;	usart_conf.pinmux_pad1 = PINMUX_UNUSED;	usart_conf.pinmux_pad2 = PINMUX_PA18C_SERCOM1_PAD2;	usart_conf.pinmux_pad3 = PINMUX_PA19C_SERCOM1_PAD3;	usart_conf.baudrate    = 9600;	while (usart_init(&COZIR_WV_100_uart, SERCOM1, &usart_conf) != STATUS_OK ) {		//add a timeout if blocked here	}	usart_register_callback(&COZIR_WV_100_uart, COZIR_WV_100_buffer_received , USART_CALLBACK_BUFFER_RECEIVED);	usart_enable_callback(&COZIR_WV_100_uart, USART_CALLBACK_BUFFER_RECEIVED);	usart_enable(&COZIR_WV_100_uart);	usart_read_job(&COZIR_WV_100_uart , &get_char_buffer);	//usart_write_buffer_wait(&COZIR_WV_100_uart  ,"*/r/n" , 3);	return true;}

bool PHPROBE_init(void){	struct usart_config usart_conf;		usart_get_config_defaults(&usart_conf);	usart_conf.mux_setting = USART_RX_3_TX_2_XCK_3;	usart_conf.pinmux_pad0 = PINMUX_UNUSED;	usart_conf.pinmux_pad1 = PINMUX_UNUSED;	usart_conf.pinmux_pad2 = PINMUX_PA10C_SERCOM0_PAD2;	usart_conf.pinmux_pad3 = PINMUX_PA11C_SERCOM0_PAD3;	usart_conf.baudrate    = 9600;	while (usart_init(&PHPROBE_uart, SERCOM0, &usart_conf) != STATUS_OK ) {		//add a timeout if blocked here	}	usart_register_callback(&PHPROBE_uart, PHPROBE_buffer_received , USART_CALLBACK_BUFFER_RECEIVED);	usart_enable_callback(&PHPROBE_uart, USART_CALLBACK_BUFFER_RECEIVED);	usart_enable(&PHPROBE_uart);	usart_read_job(&PHPROBE_uart , &get_char_buffer);	return true;	}

/** * /brief Run usb device msc unit tests * * Initializes the clock system, board and serial output, then sets up the * usb unit test suite and runs it. */int main(void){#if !SAM0	const usart_serial_options_t usart_serial_options = {		.baudrate   = CONF_TEST_BAUDRATE,		.charlength = CONF_TEST_CHARLENGTH,		.paritytype = CONF_TEST_PARITY,		.stopbits   = CONF_TEST_STOPBITS,	};#else	struct usart_config usart_conf;#endif	irq_initialize_vectors();	cpu_irq_enable();#if !SAM0	sysclk_init();	board_init();#else	system_init();#endif	// Initialize the sleep manager	sleepmgr_init();#if !SAM0	stdio_serial_init(CONF_TEST_USART, &usart_serial_options);#else	/* Configure USART for unit test output */	usart_get_config_defaults(&usart_conf);	usart_conf.mux_setting = CONF_STDIO_MUX_SETTING;	usart_conf.pinmux_pad0 = CONF_STDIO_PINMUX_PAD0;	usart_conf.pinmux_pad1 = CONF_STDIO_PINMUX_PAD1;	usart_conf.pinmux_pad2 = CONF_STDIO_PINMUX_PAD2;	usart_conf.pinmux_pad3 = CONF_STDIO_PINMUX_PAD3;	usart_conf.baudrate    = CONF_STDIO_BAUDRATE;	usart_conf.generator_source = GCLK_GENERATOR_3;	stdio_serial_init(&cdc_uart_module, CONF_STDIO_USART, &usart_conf);	usart_enable(&cdc_uart_module);#endif	// Define all the timestamp to date test cases	DEFINE_TEST_CASE(usb_msc_test, NULL,			run_usb_msc_test, NULL,			"USB Device msc enumeration test");	DEFINE_TEST_CASE(usb_msc_read_test, NULL,			run_usb_msc_read_test, NULL,			"USB MSC read access test");	DEFINE_TEST_CASE(usb_vbus_test, NULL,			run_usb_vbus_test, NULL,			"USB vbus event test");	DEFINE_TEST_CASE(usb_resume_test, NULL,			run_usb_resume_test, NULL,			"USB resume event test");	DEFINE_TEST_CASE(usb_suspend_test, NULL,			run_usb_suspend_test, NULL,			"USB suspend event test");	DEFINE_TEST_CASE(usb_sof_test, NULL,			run_usb_sof_test, NULL,			"USB sof event test");	// Put test case addresses in an array	DEFINE_TEST_ARRAY(usb_msc_tests) = {		&usb_msc_test,		&usb_msc_read_test,		&usb_vbus_test,		&usb_resume_test,		&usb_suspend_test,		&usb_sof_test,	};	// Define the test suite	DEFINE_TEST_SUITE(usb_msc_suite, usb_msc_tests,			"Common usb MSC service with test suite");	// The unit test prints message via UART which does not support deep sleep mode.#if SAM	sleepmgr_lock_mode(SLEEPMGR_ACTIVE);#else	sleepmgr_lock_mode(SLEEPMGR_IDLE);#endif	// Run all tests in the suite	test_suite_run(&usb_msc_suite);	while (1) {		// Intentionally left empty.	}}