Beispiel #1
0
// ------------------------------------
// 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;
}
Beispiel #2
0
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);
}
Beispiel #3
0
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!
}
Beispiel #5
0
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;
}
Beispiel #6
0
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;
}
Beispiel #9
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;
    }
  }
}
Beispiel #11
0
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;
}
Beispiel #12
0
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');
}
Beispiel #13
0
Datei: uart.c Projekt: 8l/beri
char uart_locked_getc()
{
    lock_acquire(&uart_lock);
    char c = uart_getc();
    lock_release(&uart_lock);
    return c;
}
Beispiel #14
0
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;
}
Beispiel #15
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");
    }
}
Beispiel #16
0
//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;
}
Beispiel #17
0
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;
}
Beispiel #18
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();
    }
}
Beispiel #19
0
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++;
	}
}
Beispiel #20
0
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;
}
Beispiel #22
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;
	}

    }
}
Beispiel #23
0
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;
}
Beispiel #24
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;
     }
     
}
Beispiel #25
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);
}
Beispiel #26
0
//------------------------------------------------------------------------
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);
}
Beispiel #27
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());
}
Beispiel #28
0
char getChar() {
	int ch;
	do {
		ch = uart_getc();
	} while (ch==UART_NO_DATA);

	return ch;
}
Beispiel #29
0
int platform_dgetc(char *c, bool wait)
{
    int ret = uart_getc(DEBUG_UART, wait);
    if (ret == -1)
        return -1;
    *c = ret;
    return 0;
}
Beispiel #30
0
char  get_onechar ( void )
{
    char x;

    x=uart_getc();
    if(x==0x0D) x=0x0A;
    show_onechar(x);
    return(x);
}