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

void uart_puts(const char *str){     while(*str) uart_putc(*str++);}

//-----------------------------------------------------------------------------static void uart_puts(char *s){  while (*s)    uart_putc(*s++);}

int main(){//uint8_t test_result=0;//************************( 1 )*******************************************************DDRD|=(1<<6)|(1<<7);//set LED pins as output//PORTD&=~(1<<3);//vibration offuart_init();//Keep this as first init so that text can be sent out in othersuart_puts("Starting up....");_delay_ms(500);PORTD|=1<<6;_delay_ms(500);PORTD&=~(1<<6);spi_init(); //initialize SPI bus as masterinit_tcnt2();//set up timer (RTC)init_twi(); //initialize TWI interfacesei();uart_puts("Pre Init...");  PORTB&=~(1<<sensor1_cs);//select sensorSPIinit_MPU(MPU9250_FULL_SCALE_4G,MPU9250_GYRO_FULL_SCALE_500DPS);//init sensorPORTB|=(1<<sensor1_cs);//deselect sensor//init_MPU(MPU9250_FULL_SCALE_4G,MPU9250_GYRO_FULL_SCALE_500DPS, MPU9250_DEFAULT_ADDRESS); //initialize the 9axis sensor//init_MPU(0,0, 0xD1); //initialize the 9axis sensor//init_MPU(MPU9250_FULL_SCALE_4G,MPU9250_GYRO_FULL_SCALE_500DPS, MPU9250_DEFAULT_ADDRESS); //initialize the 9axis sensorsram_init();//initialize sramuart_puts("Post Init...");//vibrate(100);	//Send feedback showing complete setupPORTD |=(1<<6)|(1<<7);PORTD &=~(1<<7);_delay_ms(200);PORTD |=(1<<7);PORTD &=~(1<<6);// blinks both lights to show the program is starting_delay_ms(200);PORTD |=(1<<6);_delay_ms(1000);record_shot();while(1){}        //*****************STOP POINT**********************/*test_result = test_com(0, MPU9250_DEFAULT_ADDRESS);if(test_result){uart_puts("MPU Status: OK/n");}elseuart_puts("MPU Status: FAILURE... You suck!/n");*/char rx_char;uint16_t i=0;//used for for loops//*****Fix me*******  //should set to int 0 not char '0' but the ascii zero prints better for nowfor(i=0;i<512;i++){sd_buf[i]='0';}//sets inital buffer to zero valuesuint16_t shot_count=0;while(1){//************************( 2 )*******************************************************PORTD &=~(1<<7);_delay_ms(2000);//Show red light for 2 sec, then turn green and start shotPORTD |=(1<<7);PORTD &=~(1<<6);//************************( 3 )*******************************************************//vibrate(100);record_shot();//record a shotchar shots_s[10];itoa(num_records,shots_s,10);uart_puts("In 20 seconds The number of records was: ");uart_puts(shots_s);uart_putc('/n');print_shot();shot_count++;itoa(shot_count,shots_s,10);uart_puts("Shot Number: ");uart_puts(shots_s);uart_putc('/n');//print_shot();PORTD |=(1<<6);//turn off light//vibrate(100);_delay_ms(100);vibrate(100);  //Double vibration showing end of shot//check_voltage();//Check system voltage_delay_ms(5000);//wait 60 seconds//************************( 6 )*******************************************************continue; //start over and take another shot  uart_puts("Starting Testing/n/n");  uart_putc('/r');  rx_char=uart_getc();   if(rx_char=='c')  {    uart_puts("Command line:/n/n");    rx_char=uart_getc();    while(rx_char!='c')    {      if(rx_char=='s'){}     if(rx_char=='w'){}      if(rx_char=='r'){}//buffer gets set to sector!!      if(rx_char=='i'){}//.........这里部分代码省略.........

int main(void){  dhcp dhcp_session;  int  dhcp_state;  http_server http;  http_socket httpsock[4];  http_content httpcontent[4];  char oled_msg[17];  char *pnt;  int   step;  api_init();  uart_puts(" * eCowLogic firmware /r/n");  hw_systick( hw_getfreq() / 1000 );  dhcp_session.socket = 2;  dhcp_session.buffer = (u8 *)buffer_dhcp;  dhcp_init(&dhcp_session);    oled_pos(1, 0);  oled_puts("Reseau (DHCP)   ");  step = 0;  while(1)  {    dhcp_state = dhcp_run(&dhcp_session);    if (dhcp_state == DHCP_IP_LEASED)      break;    step++;    oled_pos(1, 13);    if (step == 1) oled_puts(".  ");    if (step == 2) oled_puts(".. ");    if (step == 3) oled_puts("...");    if (step == 4)    {      step = 0;      dhcp_session.tick_1s++;      uart_putc('.');      oled_puts("   ");    }    delay(250);  }  pnt = oled_msg;  pnt += b2ds(pnt, dhcp_session.dhcp_my_ip[0]); *pnt++ = '.';  pnt += b2ds(pnt, dhcp_session.dhcp_my_ip[1]); *pnt++ = '.';  pnt += b2ds(pnt, dhcp_session.dhcp_my_ip[2]); *pnt++ = '.';  pnt += b2ds(pnt, dhcp_session.dhcp_my_ip[3]);  for ( ; pnt < (oled_msg + 16); pnt++)    *pnt = ' ';  oled_msg[16] = 0;  uart_puts("DHCP: LEASED ! ");  uart_puts(oled_msg); uart_puts("/r/n");  oled_pos(1, 0);  oled_puts(oled_msg);    spi_init();  pld_init();  //net_init();    /* Init HTTP content */  strcpy(httpcontent[0].name, "/pld");  httpcontent[0].wildcard = 0;  httpcontent[0].cgi = cgi_ng_pld;  httpcontent[0].next = &httpcontent[1];  /* Init HTTP content */  strcpy(httpcontent[1].name, "/spi");  httpcontent[1].wildcard = 0;  httpcontent[1].cgi = cgi_spi;  httpcontent[1].next = &httpcontent[2];  /* Init HTTP content */  strcpy(httpcontent[2].name, "/infos");  httpcontent[2].wildcard = 0;  httpcontent[2].cgi = cgi_info;  httpcontent[2].next = &httpcontent[3];  /* Init HTTP content */  strcpy(httpcontent[3].name, "/");  httpcontent[3].wildcard = 1;  httpcontent[3].cgi = cgi_ng_page;  httpcontent[3].next = 0;  /* Init HTTP socket */  httpsock[0].id = 4;  httpsock[0].state = 0;  httpsock[0].server = &http;  httpsock[0].next = &httpsock[1];  /* Init HTTP socket */  httpsock[1].id = 5;  httpsock[1].state = 0;  httpsock[1].server = &http;  httpsock[1].next = &httpsock[2];  /* Init HTTP socket */  httpsock[2].id = 6;  httpsock[2].state = 0;  httpsock[2].server = &http;  httpsock[2].next = &httpsock[3];  /* Init HTTP socket */  httpsock[3].id = 7;  httpsock[3].state = 0;  httpsock[3].server = &http;  httpsock[3].next = 0;//.........这里部分代码省略.........

void uart_putx(int i) {    uart_putc((i < 10) ? ('0' + i) : ('A' - 10 + i));}

int main(void){    RCC->AHB1ENR |= (RCC_AHB1ENR_GPIOBEN | RCC_AHB1ENR_GPIOCEN | RCC_AHB1ENR_GPIODEN);    RCC->APB1ENR |= (RCC_APB1ENR_SPI2EN | RCC_APB1ENR_USART3EN);    // PB11 / INT/HOLD    GPIOB->MODER |= GPIO_MODER_MODER11_0;	// open drain output    GPIOB->OTYPER |= GPIO_OTYPER_OT_11;    GPIOB->OSPEEDR |= GPIO_OSPEEDER_OSPEEDR11_1;    // PD11 / Chip Select    GPIOD->MODER |= GPIO_MODER_MODER11_0;	// open drain output    GPIOD->OTYPER |= GPIO_OTYPER_OT_11;    GPIOD->OSPEEDR |= GPIO_OSPEEDER_OSPEEDR11_1;    // PB13 / SCK    GPIOB->MODER |= GPIO_MODER_MODER13_1;	// open drain output    GPIOB->OTYPER |= GPIO_OTYPER_OT_13;    GPIOB->OSPEEDR |= GPIO_OSPEEDER_OSPEEDR13_1;    GPIOB->AFR[1] |= (0x05 << 20);    // PB14 / MISO    GPIOB->MODER |= GPIO_MODER_MODER14_1;    GPIOB->PUPDR |= GPIO_PUPDR_PUPDR14_1;    GPIOB->OSPEEDR |= GPIO_OSPEEDER_OSPEEDR14_1;    GPIOB->AFR[1] |= (0x05 << 24);    // PB15 / MOSI    GPIOB->MODER |= GPIO_MODER_MODER15_1;	// open drain output    GPIOB->OTYPER |= GPIO_OTYPER_OT_15;    GPIOB->OSPEEDR |= GPIO_OSPEEDER_OSPEEDR15_1;    GPIOB->AFR[1] |= (0x05 << 28);    // PD12 / LED    GPIOD->MODER |= GPIO_MODER_MODER12_0;    GPIOD->OSPEEDR |= GPIO_OSPEEDER_OSPEEDR12_1;    // SPI    SPI2->CR1 |= SPI_CR1_SSM | SPI_CR1_SSI | SPI_CR1_CPHA | SPI_CR1_MSTR | (SPI_CR1_BR_2 | SPI_CR1_BR_1 | SPI_CR1_BR_0);    SPI2->CR1 |= SPI_CR1_SPE;    // PC10 / TX    GPIOC->MODER |= GPIO_MODER_MODER10_1;    GPIOC->OSPEEDR |= GPIO_OSPEEDER_OSPEEDR10_0;    GPIOC->AFR[1] |= (0x07 << 8);    // PC11 / RX    GPIOC->MODER |= GPIO_MODER_MODER11_1;    GPIOC->PUPDR &= ~GPIO_PUPDR_PUPDR11;    GPIOC->AFR[1] |= (0x07 << 12);    // USART    USART3->BRR = 0x00D9; // 50.0 MHz / 0x00D9 = 115200    USART3->CR3 |= USART_CR3_DMAT;    USART3->CR1 |= (USART_CR1_RXNEIE | USART_CR1_TE | USART_CR1_RE);    USART3->CR1 |= USART_CR1_UE;    NVIC_SetPriority(USART3_IRQn, 15);    NVIC_EnableIRQ(USART3_IRQn);    __enable_irq();    volatile uint32_t i;    uint16_t data;    uart_putc(spi(0b01001100));    uart_putc(spi(0b01001100));    uart_putc(spi(0b11100001));    // SET_ADVANCED_MODE    uart_putc(spi(0b01110001));    for (;;) {        /*data = uart_getc();        if ((data & 0xFF00) == 0) {            uart_putc(spi(data));        }*/    	// LED on PD12 goes LOW        GPIOD->BSRRL = GPIO_ODR_ODR_12;        // delay        for (i = 0; i < 10000; i++);        // BAND_PASS_CMD        uart_putc(spi(0b00000000 | (40 & 0x3F)));        // Set the gain        uart_putc(spi(0b10000000 | (49 & 0x3F)));        // Set the integration time constant        uart_putc(spi(0b11000000 | (31 & 0x1F)));        // SET_ADVANCED_MODE        uart_putc(spi(0b01110001));        // int/hold LOW//.........这里部分代码省略.........

static int putchar__(char c, FILE *stream) {	uart_putc(c);	return 0;}

void putch(char ch) {	uart_putc(ch);}

int main(void){	int i;	int count = 0;		DDRB = 0;	DDRC = 0;	DDRE = 0;		// Enable the pullup on RESET pin.	#if defined(__AVR_AT90PWM316__)	PORTE = (1<<PINE0);	PORTE &= ~(1<<PINE0);	#elif defined(__AVR_ATmega328__) || defined(__AVR_ATmega328P__)	PORTC = (1<<PINC6);	PORTC &= ~(1<<PINC6);	#else	#warning "Didn't enable reset pin pullup"	#endif		// Setup all of port C as inputs, except for pin C5	SETUP_DEBUG_PINS();		// Set up the ADC single conversion pin.	DDRC  &= ~(1<<PINC6);	PORTC &= ~(1<<PINC6);		// Disable all the ADC digital inputs.	DIDR1 = 0xFF;	DIDR0 = 0xFF & ~(1<<ADC1D);		// populate the buffer with known values	ringBuffer_initialize(&txbuffer,txbuffer_storage,TXBUFFER_LEN);	ringBuffer_initialize(&adcbuffer,adcbuffer_storage,BUFFER_LEN);	ringBuffer_initialize(&rxbuffer,rxbuffer_storage,RXBUFFER_LEN);		// Populate the ADC read schedule with the mux indices that you want.	adc_mux_schedule[0] = 2;	adc_mux_schedule[1] = 10;	adc_mux_schedule[2] = 6;	adc_mux_schedule[3] = 3;			uart_init( UART_BAUD_SELECT_DOUBLE_SPEED(UART_BAUD_RATE,F_CPU), &rxbuffer, &txbuffer);	//uart_config_default_stdio();	// Translate those indices and the mask specifying which MUXes to turn on,	// to an encoded mux schedule that the ADC understands.	adc_encode_muxSchedule(adc_mux_schedule, SCHEDULE_LEN);			adc_init(ADC_MODE_MANUAL, &adcbuffer, adc_mux_schedule, SCHEDULE_LEN);	timer0_init();	sei();	uart_puts_P("/f/r/n/r/nADC and UART Demo. Commands:/n"				"b      Begin 4 channel read bursts at CLK/16K/n"				"e      End reading./n"				"s      Single conversion./n");		DEBUG_PIN1_OFF();	while(1)	{		do		{			i = uart_getc();		} while (i == UART_NO_DATA);		DEBUG_PIN1_ON();		if(i == 'b'){			uart_puts_P("Begin./n");			start_timer0();		}		else if(i == 'e'){			stop_timer0();			_delay_us(100);			uart_puts_P("End./n");		}		else if(i == 's'){			uart_puts_P("ADC");			uart_put_hex8(count);			uart_puts_P(": ");			i = adc_single_conversion(count);			uart_put_hex8((i >> 8) & 0xFF);			uart_put_hex8(i & 0xFF);			uart_putc('/n');			count = (count + 1) & 0xF;			if(count == 11)			{				count = 13;			}		}		else{

void uart0_putc(char byte){	uart_putc(UART_0, byte);}

void ieee_mainloop(void) {  int16_t cmd = 0;  set_error(ERROR_DOSVERSION);  ieee_data.bus_state = BUS_IDLE;  ieee_data.device_state = DEVICE_IDLE;  for(;;) {    switch(ieee_data.bus_state) {      case BUS_SLEEP:                               /* BUS_SLEEP */        set_atn_irq(0);        ieee_bus_idle();        set_error(ERROR_OK);        set_busy_led(0);        uart_puts_P(PSTR("ieee.c/sleep ")); set_dirty_led(1);        /* Wait until the sleep key is used again */        while (!key_pressed(KEY_SLEEP))          system_sleep();        reset_key(KEY_SLEEP);        set_atn_irq(1);        update_leds();        ieee_data.bus_state = BUS_IDLE;        break;      case BUS_IDLE:                                /* BUS_IDLE */        ieee_bus_idle();        while(IEEE_ATN) {   ;               /* wait for ATN */          if (key_pressed(KEY_NEXT | KEY_PREV | KEY_HOME)) {            change_disk();          } else if (key_pressed(KEY_SLEEP)) {            reset_key(KEY_SLEEP);            ieee_data.bus_state = BUS_SLEEP;            break;          } else if (display_found && key_pressed(KEY_DISPLAY)) {            display_service();            reset_key(KEY_DISPLAY);          }          system_sleep();      }      if (ieee_data.bus_state != BUS_SLEEP)        ieee_data.bus_state = BUS_FOUNDATN;      break;      case BUS_FOUNDATN:                            /* BUS_FOUNDATN */        ieee_data.bus_state = BUS_ATNPROCESS;        cmd = ieee_getc();      break;      case BUS_ATNPROCESS:                          /* BUS_ATNPROCESS */        if(cmd < 0) {          uart_putc('c');          ieee_data.bus_state = BUS_IDLE;          break;        } else cmd &= 0xFF;        uart_puts_p("ATN "); uart_puthex(cmd);        uart_putcrlf();        if (cmd == 0x3f) {                                  /* UNLISTEN */          if(ieee_data.device_state == DEVICE_LISTEN) {            ieee_data.device_state = DEVICE_IDLE;            uart_puts_p("UNLISTEN/r/n");          }          ieee_data.bus_state = BUS_IDLE;          break;        } else if (cmd == 0x5f) {                           /* UNTALK */          if(ieee_data.device_state == DEVICE_TALK) {            ieee_data.device_state = DEVICE_IDLE;            uart_puts_p("UNTALK/r/n");          }          ieee_data.bus_state = BUS_IDLE;          break;        } else if (cmd == (0x40 + device_address)) {        /* TALK */          uart_puts_p("TALK ");          uart_puthex(device_address); uart_putcrlf();          ieee_data.device_state = DEVICE_TALK;          /* disk drives never talk immediatly after TALK, so stay idle             and wait for a secondary address given by 0x60-0x6f DATA */          ieee_data.bus_state = BUS_IDLE;          break;        } else if (cmd == (0x20 + device_address)) {        /* LISTEN */          ieee_data.device_state = DEVICE_LISTEN;          uart_puts_p("LISTEN ");          uart_puthex(device_address); uart_putcrlf();          ieee_data.bus_state = BUS_IDLE;          break;        } else if ((cmd & 0xf0) == 0x60) {                  /* DATA */          /* 8250LP sends data while ATN is still active, so wait             for bus controller to release ATN or we will misinterpret             data as a command */          while(!IEEE_ATN);          if(ieee_data.device_state == DEVICE_LISTEN) {            cmd = ieee_listen_handler(cmd);            cmd_handler();            break;          } else if (ieee_data.device_state == DEVICE_TALK) {            ieee_data.secondary_address = cmd & 0x0f;//.........这里部分代码省略.........

static int16_t ieee_listen_handler (uint8_t cmd)/* Receive characters from IEEE-bus and write them to the   listen buffer adressed by ieee_data.secondary_address.   If a new command is received (ATN set), return it*/{  buffer_t *buf;  int16_t c;  ieee_data.secondary_address = cmd & 0x0f;  buf = find_buffer(ieee_data.secondary_address);  /* Abort if there is no buffer or it's not open for writing */  /* and it isn't an OPEN command                             */  if ((buf == NULL || !buf->write) && (cmd & 0xf0) != 0xf0) {    uart_putc('c');    return -1;  }  switch(cmd & 0xf0) {    case 0x60:      uart_puts_p("DATA L ");      break;    case 0xf0:      uart_puts_p("OPEN ");      break;    default:      uart_puts_p("Unknown LH! ");      break;  }  uart_puthex(ieee_data.secondary_address);  uart_putcrlf();  c = -1;  for(;;) {    /* Get a character ignoring timeout but but watching ATN */    while((c = ieee_getc()) < 0);    if (c  & FLAG_ATN) return c;    uart_putc('<');    if (c & FLAG_EOI) {      uart_puts_p("EOI ");      ieee_data.ieeeflags |= EOI_RECVD;    } else ieee_data.ieeeflags &= ~EOI_RECVD;    uart_puthex(c); uart_putc(' ');    c &= 0xff; /* needed for isprint */    if(isprint(c)) uart_putc(c); else uart_putc('?');    uart_putcrlf();    if((cmd & 0x0f) == 0x0f || (cmd & 0xf0) == 0xf0) {      if (command_length < CONFIG_COMMAND_BUFFER_SIZE)        command_buffer[command_length++] = c;      if (ieee_data.ieeeflags & EOI_RECVD)        /* Filenames are just a special type of command =) */        ieee_data.ieeeflags |= COMMAND_RECVD;    } else {      /* Flush buffer if full */      if (buf->mustflush) {        if (buf->refill(buf)) return -2;        /* Search the buffer again,                     */        /* it can change when using large buffers       */        buf = find_buffer(ieee_data.secondary_address);      }      buf->data[buf->position] = c;      mark_buffer_dirty(buf);      if (buf->lastused < buf->position) buf->lastused = buf->position;      buf->position++;      /* Mark buffer for flushing if position wrapped */      if (buf->position == 0) buf->mustflush = 1;      /* REL files must be syncronized on EOI */      if(buf->recordlen && (ieee_data.ieeeflags & EOI_RECVD)) {        if (buf->refill(buf)) return -2;      }    }   /* else-buffer */  }     /* for(;;) */}

//.........这里部分代码省略.........									// timer1 running on 1/8 MCU clock with clear timer/counter1 on Compare Match				// PWM frequency will be MCU clock / 8 / 512, e.g. with 1Mhz Crystal 244 Hz.				TCCR1B = _BV(CS11) | _BV(WGM12);			 				for (;;)				{   					for (i=0; i<150; i++)								/* Decrease speed of motor */					{						OCR1AL = i;						OCR1BL = i;						_delay_ms(25);									// delay 25 ms					}										for( i=150; i>0; i--)								/* Increase speed of motor */					{						OCR1AL = i;            						OCR1BL = i;						_delay_ms(25);									// delay 25 ms					}				}						}			else if(current==2)			{				subprog();				uart_init(UART_BAUD_SELECT(UART_BAUD_RATE,F_CPU)); 				uart_puts_P("/r/n/nSample code made by Robokits India for ROBOGRID. ");				uart_puts_P("/r/n/nVisit Us at www.robokits.org. ");				uart_puts_P("/r/n/nWriting number to UART: ");			 				itoa( num, buffer, 10);   // convert interger into string (decimal format)    				uart_puts(buffer);        // and transmit string to UART     							uart_putc('/r');								uart_puts_P("/n/nPress any key on keyboard: ");								for(;;)				{					c = uart_getc();					if (!(c & UART_NO_DATA))						uart_putc( (unsigned char)c );				}						}			else if(current==3)			{				subprog();				sbi(PORTA,4);				TCCR1A = 0x00;               	// disable PWM and Compare Output Mode				TCCR1B = TMC16_CK1024;       	// use CLK/1024 prescale value				TCNT1  = TIMER_1_CNT;        	// reset TCNT1								TIMSK  = _BV(TOIE1);         	// enable TCNT1 overflow 								sei();                       	// enable interrupts 								for (;;) 						// loop forever				{                      					if (bit_is_clear(PINA, 5))	//BLINK LED2 WITH NORMAL DELAY						sbi(PORTA,5);			//LED2 ON					else						//ELSE						cbi(PORTA,5);			//LED2 OFF					_delay_ms(250);									_delay_ms(250);						_delay_ms(250);						_delay_ms(250);					}			

void sendCRLF(){	uart_putc(CR);	uart_putc(LF);}

int main(){    /* we will just use ordinary idle mode */    set_sleep_mode(SLEEP_MODE_IDLE);    /* setup uart */    uart_init();    while(1)    {        /* setup sd card slot */        if(!sd_raw_init())        {#if DEBUG            uart_puts_p(PSTR("MMC/SD initialization failed/n"));#endif            continue;        }        /* open first partition */        struct partition_struct* partition = partition_open(sd_raw_read,                                                            sd_raw_read_interval,#if SD_RAW_WRITE_SUPPORT                                                            sd_raw_write,                                                            sd_raw_write_interval,#else                                                            0,                                                            0,#endif                                                            0                                                           );        if(!partition)        {            /* If the partition did not open, assume the storage device             * is a "superfloppy", i.e. has no MBR.             */            partition = partition_open(sd_raw_read,                                       sd_raw_read_interval,#if SD_RAW_WRITE_SUPPORT                                       sd_raw_write,                                       sd_raw_write_interval,#else                                       0,                                       0,#endif                                       -1                                      );            if(!partition)            {#if DEBUG                uart_puts_p(PSTR("opening partition failed/n"));#endif                continue;            }        }        /* open file system */        struct fat_fs_struct* fs = fat_open(partition);        if(!fs)        {#if DEBUG            uart_puts_p(PSTR("opening filesystem failed/n"));#endif            continue;        }        /* open root directory */        struct fat_dir_entry_struct directory;        fat_get_dir_entry_of_path(fs, "/", &directory);        struct fat_dir_struct* dd = fat_open_dir(fs, &directory);        if(!dd)        {#if DEBUG            uart_puts_p(PSTR("opening root directory failed/n"));#endif            continue;        }                /* print some card information as a boot message */        print_disk_info(fs);        /* provide a simple shell */        char buffer[24];        while(1)        {            /* print prompt */            uart_putc('>');            uart_putc(' ');            /* read command */            char* command = buffer;            if(read_line(command, sizeof(buffer)) < 1)                continue;            /* execute command */            if(strcmp_P(command, PSTR("init")) == 0)            {                break;//.........这里部分代码省略.........

void parser_process_uart(void) {		unsigned int c;	static char recbuf[BUFFERLENGTH];	static uint8_t len = 0;	static bool overflow = false;	PARSER_RET retval;	c = uart_getc();	if (c & UART_NO_DATA) {		return;	}	// check for error	if (c & UART_FRAME_ERROR) {		uart_puts_P("ERROR: UART Frame Error/n");		return;	}	if (c & UART_OVERRUN_ERROR) {		uart_puts_P("ERROR: UART Overrun Error/n");		return;	}	if (c & UART_BUFFER_OVERFLOW) {		uart_puts_P("ERROR: Buffer overflow error/n");		return;	}	// echo back the received char	if (echo) {		uart_putc((unsigned char)c);	}	// avoid inserting NULL-Byte in strings	if (c == 0x00)		return;	if (c == '/n' || c == '/r') {		if (overflow) {			uart_puts_P("ERROR: PARSER Overflow Error. String is too long./n");			overflow = false;			len = 0;			return;		}		if (len == 0)			return;		// add trailing NULL-byte		recbuf[len] = 0x00;		retval = process_cmd(recbuf, len);		len = 0;				if (retval.num == CMD_OK) {			uart_puts_P("OK");		} else if (retval.num == CMD_PONG) {			uart_puts_P("PONG");		} else if (retval.num == CMD_IGNORE) {			//uart_puts_P("IGNORE");			uart_puts_P("OK");		} else {			uart_puts_P("ERROR");		}				if (retval.string != NULL) {			uart_puts_P(": ");			uart_puts(retval.string);		}				uart_puts_P("/n");	}	else {		if (len >= BUFFERLENGTH-1) {			overflow = true;			return;		}		else {			recbuf[len++] = c;		}	}}

uint8_t print_disk_info(const struct fat_fs_struct* fs){    if(!fs)        return 0;    struct sd_raw_info disk_info;    if(!sd_raw_get_info(&disk_info))        return 0;    uart_puts_p(PSTR("manuf:  0x")); uart_putc_hex(disk_info.manufacturer); uart_putc('/n');    uart_puts_p(PSTR("oem:    ")); uart_puts((char*) disk_info.oem); uart_putc('/n');    uart_puts_p(PSTR("prod:   ")); uart_puts((char*) disk_info.product); uart_putc('/n');    uart_puts_p(PSTR("rev:    ")); uart_putc_hex(disk_info.revision); uart_putc('/n');    uart_puts_p(PSTR("serial: 0x")); uart_putdw_hex(disk_info.serial); uart_putc('/n');    uart_puts_p(PSTR("date:   ")); uart_putw_dec(disk_info.manufacturing_month); uart_putc('/');                                   uart_putw_dec(disk_info.manufacturing_year); uart_putc('/n');    uart_puts_p(PSTR("size:   ")); uart_putdw_dec(disk_info.capacity / 1024 / 1024); uart_puts_p(PSTR("MB/n"));    uart_puts_p(PSTR("copy:   ")); uart_putw_dec(disk_info.flag_copy); uart_putc('/n');    uart_puts_p(PSTR("wr.pr.: ")); uart_putw_dec(disk_info.flag_write_protect_temp); uart_putc('/');                                   uart_putw_dec(disk_info.flag_write_protect); uart_putc('/n');    uart_puts_p(PSTR("format: ")); uart_putw_dec(disk_info.format); uart_putc('/n');    uart_puts_p(PSTR("free:   ")); uart_putdw_dec(fat_get_fs_free(fs)); uart_putc('/');                                   uart_putdw_dec(fat_get_fs_size(fs)); uart_putc('/n');    return 1;}

//------------------------------------------------------------------------void hexstring ( unsigned int d ){    hexstrings(d);    uart_putc(0x0D);    uart_putc(0x0A);}

void _dputc(char c){	uart_putc(0, c);}

/* *uart_printf(char*) *Converts and formats values to be sent via char UART. Works similar to normal printf function. *INPUT: Char* EX: uart_printf("DATA: %i/r/n", datvar); *RETURN: None */void uart_printf(char *format, ...){    char c;    int i;    long l;    va_list list;														//Make the arguement list    va_start(list, format);    while(c = *format++)												//run through the input till the end.    {        if(c == '%')													//% denotes the variable format character        {            switch(c = *format++)            {                case 's':                       						// strings                    uart_puts(va_arg(list, char*));                    break;                case 'c':                       						// chars                    uart_putc(va_arg(list, char));                    break;                case 'i':                       						// signed ints                	i = va_arg(list, int);                    if(i < 0)                    {                    	i = -i;                     	uart_putc('-');                    }                    convert_dec((unsigned)i, divider + 5);                    break;                case 'u':                      							// unsigned ints                    i = va_arg(list, int);                    convert_dec((unsigned)i, divider + 5);                    break;                case 'l':                       						// signed longs                    l = va_arg(list, long);                    if(l < 0)                    {                    	l = -l;                    	uart_putc('-');                    }                    convert_dec((unsigned long)l, divider);                    break;                case 'n':                       						// unsigned longs                    l = va_arg(list, long);                    convert_dec((unsigned long)l, divider);                    break;                case 'x':                       						// 16bit Hex                    i = va_arg(list, int);                    uart_putc(convert_hex(i >> 12));                    uart_putc(convert_hex(i >> 8));                    uart_putc(convert_hex(i >> 4));                    uart_putc(convert_hex(i));                    break;                case 0:                	return;                default:                	uart_putc(c);										//can't find formating. just print it.            }        }        else        {        	uart_putc(c);        }    }

void kernel_main(uint32_t r0, uint32_t r1, uint32_t atags){	(void) r0;	(void) r1;	(void) atags; 	uart_init();	/** GPIO Register set */	volatile unsigned int *gpio = led_init();	/* Assign the address of the GPIO peripheral (Using ARM Physical Address) */    //gpio = (unsigned int*)GPIO_BASE;    /* Write 1 to the GPIO16 init nibble in the Function Select 1 GPIO       peripheral register to enable GPIO16 as an output */    //gpio[LED_GPFSEL] |= (1 << LED_GPFBIT);	(void) r0;	(void) r1;	(void) atags; 	uart_init();	uart_puts("> Hello, World!/r/n");	int str_len = 80;	char stringin[str_len];	int i=0;	uart_puts("> ");	int x = 0;	int *calc = &x;	while (true){		//art_puts("hello");		//led_blink(gpio, .25);		char x = uart_getc();		//Checks if current str is being written outside size allotment		if (i > str_len-1){			uart_puts(stringin);			reset_string(stringin, i);					uart_puts("Max string len reached/r/n");			i = 0;		}		// if enter is pressed		else if (x == '/r')		{			uart_puts("/r/n");			if (memcmp(stringin, "calc", sizeof("calc")) == 0) {				uart_puts("CALC RECOGNIZED!/r/n");				calc_init();				*calc = 1;			}			if (memcmp(stringin, "blink", sizeof("blink")) == 0) {				uart_puts("LEDDDDDD!/r/n");				led_blink(gpio, 1);			}			if (memcmp(stringin, "stop", sizeof("stop")) == 0) {				uart_puts("LEDDDDDD STOP!/r/n");				led_blink(gpio, 0);			}			else{				uart_puts(stringin);				uart_puts("/n");				// char str[16];				// int c = -146;				// uart_puts(itos(c, str));			}						reset_string(stringin, i);			uart_puts("> ");			i = 0;		}		else if (x == 127 || x == 8) // backspace character		{			if (i>0)			{				uart_putc('/b'); // move cursor back				uart_putc(' '); // insert space in terminal				uart_putc('/b'); // move cursor back before space				stringin[i-1] = 0x00; // replace last char with empty				i--; // decrement length			}		}		else{			stringin[i] = x;			uart_putc(stringin[i]);			i++;		}	}}

voidarch_debug_serial_putchar(const char c){	uart_putc(uart_debug_port(), c);}

void putc_escaped(char c){    if(c == '//'){        uart_putc(c);    }    uart_putc(c);}

void uart_puts(char *s){	while(*s){		uart_putc(*s);		s++;	}}

void writeString(char *str){	while (*str) {		uart_putc(*str++);	}}

int main(void){	init_uart();																			// UART initalisieren und einschalten. Alle n
C++ uart_puts函数代码示例
C++ uart_printf函数代码示例