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

// ------------------------------------// Fonction    : uart_gets_startWithAndUntil// Description : ...//               ...// Param(s)    : ...//               ...// Output      : ...// ------------------------------------uint8_t uart_gets_startWithAndUntil(char* str, char startch, char stopch, uint8_t maxLength){    uint8_t i;    char c;/* Pourquoi l'utilisation d'une variable supplémentaire ? (double les affectations) */    do    {        c = uart_getc();    } while(c != startch);    str[0] = c;    for(i = 1; i < (maxLength); i++)    {        c = uart_getc();        str[i] = c;        if (c == stopch) {            //i++;            break;	// we're done if stopchar is found        }    }    //str[i] = '/0'; On ne traite pas des string, innutile d'avoir un '/0' en fin de trame    return i;}

static intsunkbd_probe_keyboard(struct uart_devinfo *di){	int tries;	for (tries = 5; tries != 0; tries--) {		int ltries;		uart_putc(di, SKBD_CMD_RESET);		for (ltries = 1000; ltries != 0; ltries--) {			if (uart_poll(di) == SKBD_RSP_RESET)				break;			DELAY(1000);		}		if (ltries == 0)			continue;		for (ltries = 1000; ltries != 0; ltries--) {			if (uart_poll(di) == SKBD_RSP_IDLE)				break;			DELAY(1000);		}		if (ltries == 0)			continue;		uart_putc(di, SKBD_CMD_LAYOUT);		if (uart_getc(di) != SKBD_RSP_LAYOUT)			break;		return (uart_getc(di));	}	return (-1);}

void readhex2buffer(void* buffer, int n){	char c;	uint8_t i;	//	DEBUG_S("/r/nDBG: n="); DEBUG_B(n&0xff); DEBUG_S("/r/n");	for(i=0; i<n; ++i){		c = uart_getc();		if ('0'<= c && '9'>=c){			((uint8_t*)buffer)[i] = c - '0';		} else {			c &= ~('A' ^ 'a'); /* make all uppercase */ 			if ('A'<= c && 'F'>=c){				((uint8_t*)buffer)[i] = c - 'A' + 10;			} else {				/* oh shit, wrong char */			}		}				((uint8_t*)buffer)[i] <<= 4;				c = uart_getc();		if ('0'<= c && '9'>=c){			((uint8_t*)buffer)[i] |= c - '0';		} else {			c &= ~('A' ^ 'a'); /* make all uppercase */ 			if ('A'<= c && 'F'>=c){				((uint8_t*)buffer)[i] |= c - 'A' + 10;			} else {				/* oh shit, wrong char */			}		}	} /* for i=0 .. n */}

void loadAddress( void ) {	// read high first, then low	ubyte addrH = uart_getc( );	ubyte addrL = uart_getc( );		currentAddress = addrH;	currentAddress <<= 8;	currentAddress |= addrL;		uart_putc( BYTE_CR ); // done!}

int getnextwordn(char *s, int n){ /* words are seperated by spaces, lf or cr */	char c = ' ';	do{		c=uart_getc(); 	}while(c==' ' || c=='/r' || c=='/n');	*s++ = c;	do{ 	  *s++ = c = uart_getc();	}while(c!=' ' && c!='/r' && c!='/n' && --n);	*(s-1) = '/0';	return n;}

char handshake(){	uart_flush();	_delay_ms(100);		while(uart_available()==0)	{		PORTB |=(1<<PB5);		_delay_ms(100);		PORTB &=~(1<<PB5);		_delay_ms(100);			}		if (uart_getc() == 'a')	{		PORTB |=(1<<PB5);		_delay_ms(50);		PORTB &=~(1<<PB5);		_delay_ms(50);		PORTB |=(1<<PB5);		_delay_ms(50);		PORTB &=~(1<<PB5);		_delay_ms(50);			}		uart_putc('b');	while(uart_available()==0)	{		PORTB |=(1<<PB5);		_delay_ms(20);				PORTB &= ~(1<<PB5);		_delay_ms(20);	}		if (uart_getc() == 'c')	{		uart_putc('d');		PortMode = REGULAR;		return(0);  // handshake success	}	else	{		uart_puts_p(PSTR("/n Debug mode"));		PortMode = DEBUG;		return(1);  // debug mode	}}

void universalWrite3( void ) {	ubyte reply;		// in this order exactly -- DONT rely on order of execution in function parameters!	ubyte a = uart_getc( );	ubyte b = uart_getc( );	ubyte c = uart_getc( );		reply = spi_avrTransaction( a, b, c, 0 );	uart_putc( reply );		delay_ms( WD_FLASH );		uart_putc( BYTE_CR ); // done!}

int main(void){    char message[MAX_MESSAGE_LENGTH];	//Buffer for UART messages    int uart_recv;    char uart_err;    char uart_char;    ioinit();    sleep_enable();    set_sleep_mode(SLEEP_MODE_IDLE);    sei();    message_index = 0;    while(1){        uart_recv = uart_getc();        uart_err = (uart_recv & 0xff00) >> 8;        uart_char = uart_recv & 0x00ff;        if(!(uart_err) && message_index < MAX_MESSAGE_LENGTH && uart_char != '/r')        {            message[message_index++] = uart_char;        }        if(uart_char == '/n')        {            message[message_index-1]='/0';            message_index = 0;            interpret_message(message);        }         sleep_cpu(); // we wake up when we receive a character, right?    }    return 0;}

static irqreturn_t uart_rxint(int irq, void *dev_id)//  interrupt handler or interrupt service routine (ISR)// read this - http://www.makelinux.net/books/lkd2/?u=ch06lev1sec3// static irqreturn_t intr_handler(int irq, void *dev_id, struct pt_regs *regs) {  struct uart_port *port = (struct uart_port *) dev_id;  struct tty_struct *tty = port->state->port.tty;  // What is the use of this ?   unsigned int status, data;  /* ... */  do {    /* ... */    /* Read data */    data   = uart_getc(port);    /* Normal, overrun, parity, frame error? */    status = uart_status(port);    /* Dispatch to the tty layer */    tty_insert_flip_char(tty, data, status);    /* ... */  } while (more_chars_to_be_read()); /* More chars */  /* ... */  tty_flip_buffer_push(tty);  return IRQ_HANDLED;}

void loopCommandLine(void) {  // print status if we're not in the menu  if (! menuEnabled) {    if (TimerReached(&cmdline_looptime, 1000)) {      printStatus();    }  }   // check for serial command  unsigned int c = uart_getc();  if (!(c & UART_NO_DATA)) {    if (! menuEnabled) {      menuEnabled=1;      printHelp();    }    switch((char) c) {      case 'x': case 'X':  // terminates menu        uart_puts_P("Leaving menu." NEWLINESTR);        menuEnabled=0; break;      case 'b': case 'B':  // show PID values        printPID(); break;      case 'r': case 'R':  // reset PID values        restorePIDDefault(); break;      case 'o': case 'O':  // print out PID debug data        togglePIDDebug(); break;      case 'p':        setPID_P(getPID_P() - delta); printPID(); break;      case 'P':        setPID_P(getPID_P() + delta); printPID();break;      case 'i':        setPID_I(getPID_I() - delta); printPID(); break;      case 'I':        setPID_I(getPID_I() + delta); printPID(); break;      case 'd':        setPID_D(getPID_D() - delta); printPID(); break;      case 'D':        setPID_D(getPID_D() + delta); printPID(); break;      case 't':        setPIDSetpoint(getPIDSetpoint() - delta); printPID(); break;      case 'T':        setPIDSetpoint(getPIDSetpoint() + delta); printPID(); break;      case 's': case 'S':        savePIDConfig(); break;      case '+':  {// adjust delta          delta *= 10.0;           if (delta > MAX_DELTA) delta = MAX_DELTA;          uart_print_delta();          break;        }      case '-':  {// adjust delta          delta /= 10.0;           if (delta < MIN_DELTA) delta = MIN_DELTA;          uart_print_delta();          break;        }      case '?': // show menu        printHelp(); break;    }  }}

uint8_t read_line(char* buffer, uint8_t buffer_length){    memset(buffer, 0, buffer_length);    uint8_t read_length = 0;    while(read_length < buffer_length - 1)    {        uint8_t c = uart_getc();        uart_putc(c);        if(c != '/n')        {            buffer[read_length] = c;        }        else        {            buffer[read_length] = '/0';            break;        }                ++read_length;    }    return read_length;}

void uart_gets(uint8_t* buf, size_t len){    size_t recv = 0;    while(recv < len - 1) {        uint8_t c = uart_getc();        switch(c) {            /* end of line */            case '/n':                buf[recv] = '/0';                uart_putc('/n');                return;            /* backspace */            case 0x08:                uart_putc(c);            case 0x7f:                --recv;                break;            /* other characters */            default:                uart_putc(c);                buf[recv++] = c;        }    }    buf[len-1] = '/0';    uart_putc('/n');}

char uart_locked_getc(){    lock_acquire(&uart_lock);    char c = uart_getc();    lock_release(&uart_lock);    return c;}

int main() {        uart_init();        moar_init();        uart_puts(": RobOS :/r/n");        while (1) {                uart_puts(">");                char c = uart_getc();                int found = 0, ret;                for (int i = 0; i < nfuncs; ++i) {                        if (c == funcs[i].cmd) {                                ret = funcs[i].fn();                                found = 1;                                break;                        }                }                if (!found) {                        uart_puts(": Not a command: ");                        uart_putc(c);                        uart_puts(" :/r/n");                }                if (ret) break;        }        uart_puts(": bye :");        return 0;}

void write_file(){    unsigned long len = 0;    int have_begin = 0;    unsigned char* buf = (unsigned char*)0x52000000;    int nodata_time = 0;    unsigned char c;    printf("Use minicom to send file./n");    while(1) {        if(uart_getc_nowait(&buf[len]) == 0) {            have_begin = 1;            nodata_time = 0;            len++;        } else {            if(have_begin) {                nodata_time++;            }        }        if(nodata_time == 1000) {            break;        }    }    printf("Have get %d bytes data/n",len);    printf("Press y to program: ");    c = uart_getc();    if(c == 'y' || c == 'Y') {        nand_erase_block(0);        nand_write_page(0,buf,len);        printf("/nUpdate program successful/n");    } else {        printf("/nUpdate program cancel/n");    }}

//reads a max 32 char string from uart, supporting delete chars.static char* readString(void){	static char rx[33];	char tmp;	BYTE i = 0;	while((tmp = uart_getc()) != '/n' && tmp != '/r') {		if (tmp == 0x7f) {			if (i > 0) {				rx[--i] = 0;				uart_putc(tmp);			}			continue;		}		if (i < sizeof(rx) - 1) {			if (validChar(tmp)) {				rx[i++] = tmp;				uart_putc(tmp);			}		}	}	rx[i] = 0;		return rx;}

int main( void ) {	// initalise UART	uart_init( UART_BAUD_RATE );		statusLed_init( );		// flash status LED for a bit	statusLed_orange( );	delay_ms( 500 );	statusLed_green( );		// uart_getc should block until data received	uart_setBlocking( true );		while ( 1 ) {		// main loop of the programmer				if ( uart_hasData( ) ) {			unsigned char cmd = uart_getc( );						processCommand( cmd );		}	}	return 0;}

void rt_fh_uart_handler(int vector, void *param){    int status;    unsigned int ret;    struct fh_uart *uart;    unsigned int reg_status;    rt_device_t dev = (rt_device_t)param;    uart = (struct fh_uart *)dev->user_data;    status = uart_get_iir_status(uart->uart_port);    if (status & UART_IIR_NOINT)    {        return;    }    if(status & UART_IIR_THREMPTY) {        //first close tx isr        uart_disable_irq(uart->uart_port,UART_IER_ETBEI);        rt_hw_serial_isr((struct rt_serial_device *)dev, RT_SERIAL_EVENT_TX_DONE);    }    else if((status & UART_IIR_CHRTOUT)==UART_IIR_CHRTOUT) {        //bug....        //if no data in rx fifo        reg_status = uart_get_status(uart->uart_port);        if((reg_status & 1<<3) == 0)            ret = uart_getc(uart->uart_port);    }    else {        rt_interrupt_enter();        rt_hw_serial_isr((struct rt_serial_device *)dev, RT_SERIAL_EVENT_RX_IND);        rt_interrupt_leave();    }}

int main(void){    WDTCTL = WDTPW + WDTHOLD; 			//Stop WDT    BCSCTL1 = CALBC1_8MHZ; 				//Set DCO to 8Mhz    DCOCTL = CALDCO_8MHZ; 				//Set DCO to 8Mhz    uart_init();						//Initialize the UART connection    __enable_interrupt();				//Interrupts Enabled    uart_puts((char *)"/n/rExpect GPS data here.. /n/r");	int idx = 0;	char c;	while(c = uart_getc()){		    if ( idx == 0 && c != '$' ){ continue; }		if ( c == '/r'){//its the end of the line! 			gps_string[idx+1] = '/0';			idx = 0;			uart_putline(gps_string);			continue;		}else{			gps_string[idx] = c;		}		idx++;	}}

void cmd_write (uint64_t cluster, uint8_t adcport, uint64_t maxsize, uint8_t speed){	uart_puts_P("Writing.../r/n");	uint16_t maxblocks = maxsize / 512;	uint16_t block = 0;	char c = 0x00;	while(c != 'q')	{		char values[512] = {0x00};		for (uint16_t i = 0; i<=80; ++i)		{			adc_request(adcport);			uint16_t adcvalue = adc_read();			string_append(values, num2str(adcvalue, 10));			string_append(values, "/r/n");			for (uint8_t d = 0; d<=speed; ++d)				_delay_ms(3);			uart_puts(num2str(i, 10));			uart_puts(": ");			uart_puts(num2str(adcvalue, 10));			uart_puts("/r/n");			c = uart_getc();			if (c == 'q') break;		}		fat_write_file(cluster, (unsigned char*)values, block);		++block;		if (block >= maxblocks) break;	}	uart_puts_P("...done/r/n");}

int main(void){		DDRC = 0x00;				uart_init( UART_BAUD_SELECT(UART_BAUD_RATE,F_CPU) );	sei();	unsigned int c;	while(1){		c = uart_getc();		if(c & UART_NO_DATA){				/*			 	* NO UART DATA available			 	*/		}		else{				/*				 *  New Data is avialable at the port.				 *  check the frame for overrun errro				 */				if ( c & UART_FRAME_ERROR ){	   					/* Framing Error detected, i.e no stop bit detected */						uart_puts_P("UART Frame Error: ");				}					if ( c & UART_OVERRUN_ERROR ){										/* 						 *						 * Overrun, a character already present in the UART UDR register was 				 		 *						 * not read by the interrupt handler before the next character arrived,						 * one or more received characters have been dropped				  		 *					 		 *                                                                  						 */						uart_puts_P("UART Overrun Error: ");						}				if ( c & UART_BUFFER_OVERFLOW ){						/* 						 *					 	 * We are not reading the receive buffer fast enough,						 *						 * one or more received character have been dropped 					 	 *					 	 */						uart_puts_P("Buffer overflow error: ");				}				processData(c);			//	PORTC = c;		}	}	return 0;}

void read(void) {    if (tx_ready == 1) {	return;    }    while(1) {	unsigned int ci = uart_getc();	if (ci & UART_NO_DATA) {	    return;	}	uint8_t cc = (uint8_t)ci;	if (hexconvert(cc) != 255) {	    if (tx_toggle == 0) {		tx_high = hexconvert(cc);	    } else {		tx_low = hexconvert(cc);		tx_buf[tx_pos++] = tx_high * 16 + tx_low;	    }	    tx_toggle ^= 1;	}	if (cc == '/r' || cc == '/n' || tx_pos >= sizeof(tx_buf) - 1) {		tx_ready = 1;		tx_toggle = 0;		return;	}    }}

int8_t gsm_send_check_resp(				char * cmd,				char * resp,				uint8_t * resp_store,				uint32_t timeout		){	bzero(resp_store, 512);	_gsm_print(cmd);	vTaskDelay(timeout);	uint8_t i = 0;	do	{		char c = uart_getc(3);		resp_store[i] = (uint8_t)c;		i++;	}	while(uart3.num_bytes > 0);	//_debug_print(resp_store);	char * str = strstr(resp_store, resp);	if(str != NULL)	{		//_debug_print("found/r/n");		return 1;	}	else	{		//_debug_print("notfound/r/n");		return -1;	}	/* Never execute */	return 0;}

void serial_periodic( void ) {     // transfer uart buffer     while (1) {	  	  uint16_t c = uart_getc();	  if (c == UART_NO_DATA)	       break;	  	  if (c & 0xff00)	       continue;	  	  if (c == 10)	       continue;	  	  buffer[buf_cnt++] = c;	  buffer[buf_cnt]   = 0;     }                    // EOT?     if (buf_cnt && (buffer[buf_cnt-1] == 13)) {	  	  wd_ticks = 0;	  buffer[--buf_cnt] = 0;	  	  parse_buffer();	  	  buffer[0] = 0;	  buf_cnt   = 0;     }     }

uint8_t uart_get_valid_char(){	uint16_t buffer = 0;	do{		buffer = uart_getc();	}while((buffer & UART_NO_DATA) || (buffer & UART_OVERRUN_ERROR) || (buffer & UART_BUFFER_OVERFLOW));	return (uint8_t)(buffer & 0xff);}

//------------------------------------------------------------------------int notmain ( unsigned int earlypc ){    unsigned int ra;    uart_init();    for(ra=0;ra<30000;ra++)    {        //uart_putc(0x30|(ra&7));    }    //for(ra=0;ra<100;ra++) uart_putc(0x55);    //probably a better way to flush the rx fifo.  depending on if and    //which bootloader you used you might have some stuff show up in the    //rx fifo.    while(1)    {        if(GET32(UART0_FR)&0x10) break;        GET32(UART0_DR);    }    printf("Hello World!/n");    printf("0x%08X/n",earlypc);    printf("%u/n",earlypc);    while(1)    {        ra=uart_getc();        if(ra==0x0D) uart_putc(0x0A);        uart_putc(ra);    }    return(0);}

void kernel_main(uint32_t r0 __attribute__((unused)), uint32_t r1 __attribute__((unused)), uint32_t atags __attribute__((unused))) {  uart_init();  shell_start();  while (true)    uart_putc(uart_getc());}

char getChar() {	int ch;	do {		ch = uart_getc();	} while (ch==UART_NO_DATA);	return ch;}

int platform_dgetc(char *c, bool wait){    int ret = uart_getc(DEBUG_UART, wait);    if (ret == -1)        return -1;    *c = ret;    return 0;}

char  get_onechar ( void ){    char x;    x=uart_getc();    if(x==0x0D) x=0x0A;    show_onechar(x);    return(x);}