// ------------------------------------ // 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 int sunkbd_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); }