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

int usart_get_echo_line(volatile avr32_usart_t *usart){  int rx_char;  int retval = USART_SUCCESS;  while (1)  {    rx_char = usart_getchar(usart);    if (rx_char == USART_FAILURE)    {      usart_write_line(usart, "Error!!!/n");      break;    }    if (rx_char == '/x03')    {      retval = USART_FAILURE;      break;    }    usart_putchar(usart, rx_char);    if (rx_char == '/r')    {      usart_putchar(usart, '/n');      break;    }  }  return retval;}

static void sim900_put_string(const char * const sz,const uint8_t isPGM){	//	debug_string(NORMAL,PSTR("(sim900_put_string) IN/r/n"),true);	const char * p = sz;	if(isPGM) {		while(1) {			const char c = nvm_flash_read_byte((flash_addr_t)p++);			if(0==c) break;			while (usart_data_register_is_empty(USART_GPRS) == false) {}			usart_put(USART_GPRS, c);			if(g_log_verbosity>NORMAL) usart_putchar(USART_DEBUG,c);		}		} else {		while(1) {			const char c = *p++;			if(0==c) break;			while (usart_data_register_is_empty(USART_GPRS) == false) {}			usart_put(USART_GPRS, c);			if(g_log_verbosity>NORMAL) usart_putchar(USART_DEBUG,c);		}	}//	debug_string(NORMAL,PSTR("(sim900_put_string) OUT/r/n"),true);		}

/* *  putchar which translates LF->CRLF */int putchar(int c){    if (c == '/n')        usart_putchar(CONF_UART, '/r');    usart_putchar(CONF_UART, c);    return c;}

int main(void){    //init the UART -- uart_init() is in uart.c  usart_init ( MYUBRR );  sei();  while(1)  {      // fixed input    unsigned char f00 = usart_getchar();    unsigned char f01 = usart_getchar();    unsigned char f10 = usart_getchar();    unsigned char f11 = usart_getchar();        fix0 = ((int)f00 << 8) + ((int)f01);    fix1 = ((int)f10 << 8) + ((int)f11);        // test multiply     prod = multfix(fix0, fix1) ;    unsigned char out0 = (unsigned char)((prod >> 8) & 0xFF);    unsigned char out1 = (unsigned char)(prod & 0xFF);        usart_putchar(out0);    usart_putchar(out1);      }} 

int io_getc(char *c){        int ci;        int status;        status = usart_read_char(&CONFIG_CONSOLE_PORT, &ci);        if (status == USART_RX_EMPTY)                return 1;        if (status == USART_RX_ERROR) {                CONFIG_CONSOLE_PORT.cr = AVR32_USART_CR_RSTSTA_MASK;                return 1;        }        /* Echo char. */        if (ci == '/r')                usart_putchar(&CONFIG_CONSOLE_PORT, '/n');        else if (ci == '/b'){                usart_putchar(&CONFIG_CONSOLE_PORT, ci);                usart_putchar(&CONFIG_CONSOLE_PORT, ' ');                usart_putchar(&CONFIG_CONSOLE_PORT, ci);        }        else                usart_putchar(&CONFIG_CONSOLE_PORT, ci);        *c = ci;        return 0;}

void print_uart(char *buffer){  int i;//  for (i=0;i<strlen(buffer);i++)  for (i=0;buffer[i] != '/0' ;i++)  usart_putchar(buffer[i]);  usart_putchar(0x0D);  usart_putchar(0x0A);  }

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_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_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);}

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);}

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_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;}

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;}

void usart_hex(unsigned char c){	#define HI(b)	((b>>4) & 0xf)	#define LO(b)	(b & 0xf)	#define HE(b)	(((b & 0x7)-1) | 0x40)		if (HI(c)>9)		usart_putchar(HE(HI(c)));	else		usart_putchar(0x30 | HI(c));	if (LO(c)>9)		usart_putchar(HE(LO(c)));	else		usart_putchar(0x30 | LO(c));}

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 usart_init(void){    const uint16_t ubbr = 2000000UL / (2 * BAUD) - 1;    UBRR1H = ubbr >> 8;    UBRR1L = ubbr;    UCSR1B = (1<<RXEN1) | (1<<TXEN1);    /* 8 data bits, 1 stop bit */    UCSR1C = (1<<UCSZ11) | (1<<UCSZ10);    DDRD |= 1<<1;    usart_putchar('A', NULL);    usart_putchar('/n', NULL);}

/*Start the serial module to play thestrings via USART serail communication*/static void play_serial(){	uint8_t recieved_byte;	bool canContinue = true;	while(canContinue) {		recieved_byte = usart_getchar(USART_SERIAL);		usart_putchar(USART_SERIAL, recieved_byte);		switch(recieved_byte) {			case '6':				solenoid_high_low(STRING_SIX);				break;			case '5':				solenoid_high_low(STRING_FIVE);				break;			case '4':				solenoid_high_low(STRING_FOUR);				break;			case '3':				solenoid_high_low(STRING_THREE);				break;			case '2':				solenoid_high_low(STRING_TWO);				break;			case '1':				solenoid_high_low(STRING_ONE);				break;			case '0':				canContinue = false;				break;			}	}}

void BUFFERED_SIO_SendHandler (void){    // Something to send ?    if (BUFFERED_SIO_TxBuffer_StartPointer == BUFFERED_SIO_TxBuffer_EndPointer)    {        return;    }    BUFFERED_SIO_TxBuffer_StartPointer++;    // Rollover ?    if (BUFFERED_SIO_TX_BUFFER_SIZE <= BUFFERED_SIO_TxBuffer_StartPointer)    {        BUFFERED_SIO_TxBuffer_StartPointer = 0;    }    // Send char    usart_putchar (BUFFERED_SIO_USART, BUFFERED_SIO_TxBuffer[BUFFERED_SIO_TxBuffer_StartPointer]);    // Enable USART Tx interrupt for transmitting all chars    Disable_global_interrupt ();    BUFFERED_SIO_USART->IER.txempty = 1;    Enable_global_interrupt ();}

void usart_putstr(char *str){	do	{		usart_putchar(*str++);	}while(*str!='/0');}

/** * /brief Test physical loop-back with some characters in sunc mode. * * This function sends a character over USART on loop back to verify that init * and sending/receiving works. A jumper is connected on the USART. * * /param test Current test case. */static void run_loopback_syncmode_test(const struct test_case *test){	uint8_t out_c = 'c';	uint8_t in_c  = 0;        port_pin_t sck_pin;                sysclk_enable_module(POWER_RED_REG0, PRUSART0_bm);                usart_set_mode(&CONF_UNIT_USART, USART_CMODE_SYNCHRONOUS_gc);	sck_pin = IOPORT_CREATE_PIN(PORTE, 2);	ioport_configure_port_pin(ioport_pin_to_port(sck_pin),				ioport_pin_to_mask(sck_pin),				IOPORT_DIR_OUTPUT | IOPORT_INIT_HIGH );                usart_spi_set_baudrate(&CONF_UNIT_USART, CONF_UNIT_BAUDRATE,			sysclk_get_source_clock_hz());	usart_tx_enable(&CONF_UNIT_USART);	usart_rx_enable(&CONF_UNIT_USART);	usart_putchar(&CONF_UNIT_USART, out_c);	in_c = usart_getchar(&CONF_UNIT_USART);	test_assert_true(test, in_c == out_c,	   "Read character through sync mode is not correct: %d != %d", in_c, out_c);			}

// BSB 20120810: Added rtos_delaychar read_dbg_char(char echo, char rtos_delay, char checksum_mode){	volatile static char dbg_checksum = 0; // should be uint8_t??	char read_data; // should be uint8_t??	// dbg_checksum is a crude checksum mechanism compatible by other debug code by BSB.	if (checksum_mode == DBG_CHECKSUM_NORMAL)	{		// Redirection to the debug USART.		if (rtos_delay == RTOS_WAIT) {			// Wait for uart RX register to fill.			while (!usart_test_hit(DBG_USART))				  vTaskDelay(120);				// Giving 12ms to RTOS all the while		}		read_data = usart_getchar(DBG_USART); // returns int	  	if (echo == DBG_ECHO)	  		usart_putchar(DBG_USART, read_data);		dbg_checksum += read_data;	// Checksum function is addition...		dbg_checksum &= 0xFF;		// ... of which we save 8 lsbs. Redundant code line?		return read_data;	}	else if (checksum_mode==DBG_CHECKSUM_RESET)		dbg_checksum = 0;	// Last alternative, DBG_CHECKSUM_READOUT, not tested	return dbg_checksum;}

int main (void){    sysclk_init();	pmic_init();    port_init();	tc_init();	wdt_set_timeout_period(WDT_TIMEOUT_PERIOD_32CLK);	wdt_enable();	usart_init();	spi_init();		char str[200];	uint8_t count ;	count = sprintf(str,"RESET");	for (uint8_t i=0;i<count;i++)	usart_putchar(&USARTE0,str[i]);	nrf_init(Address);	sei();		for (uint8_t i=0;i<Max_Robot;i++)	{		Robot_D_tmp[2][i].RID=12;	}	while (1)	{			}}

void send2uart(char *buffer){  int i;//  for (i=0;i<strlen(buffer);i++)  for (i=0;buffer[i] != '/0' ;i++)  usart_putchar(buffer[i]);}

/*! /brief Writes a number of bytes, at most /a size, from the memory area *         pointed to by /a buffer. * * If /a buffer is zero then /ref __write performs flushing of internal buffers, * if any. In this case, /a handle can be /c -1 to indicate that all handles * should be flushed. * * /param handle File handle to write to. * /param buffer Pointer to buffer to read bytes to write from. * /param size Number of bytes to write. * * /return The number of bytes written, or /c _LLIO_ERROR on failure. */size_t __write(int handle, const unsigned char *buffer, size_t size){    size_t nChars = 0;    if (buffer == 0) {        // This means that we should flush internal buffers.        return 0;    }    // This implementation only writes to stdout and stderr.    // For all other file handles, it returns failure.    if (handle != _LLIO_STDOUT && handle != _LLIO_STDERR) {        return _LLIO_ERROR;    }    for (; size != 0; --size) {        if (usart_putchar(stdio_usart_base, *buffer++) < 0) {            return _LLIO_ERROR;        }        ++nChars;    }    return nChars;}

platform_result_t platform_uart_transmit_bytes( platform_uart_driver_t* driver, const uint8_t* data_out, uint32_t size ){    UNUSED_PARAMETER(driver);    UNUSED_PARAMETER(data_out);    UNUSED_PARAMETER(size);    pdc_packet_t dma_packet;    /* Limitation: SAM4S doesn't support DMA transfer from embedded flash.     * If data_out address is not within RAM range, use normal write to THR.     */    if ( data_out >= (const uint8_t*)RAM_START_ADDR && data_out < (const uint8_t*)RAM_END_ADDR )    {        /* Initialise TPR and TCR register values. TNPR and TNCR are unused */        dma_packet.ul_addr = (uint32_t)data_out;        dma_packet.ul_size = (uint32_t)size;        pdc_tx_init( usart_get_pdc_base( driver->peripheral->peripheral ), &dma_packet, NULL );        /* Enable Tx DMA transmission */        pdc_enable_transfer( usart_get_pdc_base( driver->peripheral->peripheral ), PERIPH_PTCR_TXTEN );        host_rtos_get_semaphore( &driver->tx_dma_complete, NEVER_TIMEOUT, WICED_FALSE );    }    else    {        while ( size > 0 )        {            usart_putchar( driver->peripheral->peripheral, (uint32_t)*data_out++ );            size--;        }    }    return PLATFORM_SUCCESS;}

void USART_send(char* in, char number){    for (char c=0; c<number; c++)    {        usart_putchar(USART_SERIAL,*(in+c));    }}

/*! /brief Receive one byte from an SPI device using USART in SPI mode. * * /param p_usart Base address of the USART instance. * /param data    Pointer to the data byte where to store the received data. * * /pre USART device must be selected with usart_spi_select_device() first. */void usart_spi_read_single(Usart *p_usart, uint8_t *data){	/* Dummy write one data to slave in order to read data. */	usart_putchar(p_usart, CONFIG_USART_SPI_DUMMY);	usart_getchar(p_usart, (uint32_t*)data);}

/* usart_out - prints out a C-string until it sees a null byte */void usart_out(char* str){        while (*str) {                usart_putchar(*str);                str++;        }}

	int usart_putchar(char c, FILE *stream) {		if (c == '/n') {			usart_putchar('/r', stream);		}		loop_until_bit_is_set(UCSR0A, UDRE0);		UDR0 = c;		return 0;	}

inline void sendUARTdata(uint8_t data[], uint8_t length) {		uint8_t i;		if (length > 1) {				for (i = 0; i < length; i++) {			usart_putchar(USART_SERIAL_EXAMPLE, data[i]);			}	} else {		usart_putchar(USART_SERIAL_EXAMPLE, data[0]);		usart_putchar(USART_SERIAL_EXAMPLE, '/r');		usart_putchar(USART_SERIAL_EXAMPLE, '/n');	}	}