char *gets(char * s)
{
char * buf = s;
char c;
while (1)
{
c = uart_getchar();
// if c is user input "Enter", then end
if (c == '\r')
break;
// if c is like a, b, c, d, then fill
// if c is not '\b'
if (c != '\b')
{
*buf++ = c;
uart_putchar(c);
}
else
{
// if buf > s
if (buf > s)
{
buf--;
//*buf = ' ';
uart_putchar('\b');
uart_putchar(' ');
uart_putchar('\b');
}
}
}
*buf = '\0';
uart_putchar('\r');
uart_putchar('\n');
return buf;
}
// ham nay duoc su dung trong ngat uart khi nhan ban tin dieu khien
// tu gateway
// bien rx_data la bien luu gia tri data nhan tu uart
void dieukhien_van()
{
unsigned long i;
rx_data = RCREG;
//nhan du lieu va dua vao du lieu nhan dc vao bien data
// check xem ban tin du lieu la gi
switch(rx_data)
{
// nhan duoc ban tin bat van 1
case 0x81:
{
Van1=1; // bat van 1
//gui lai ban tin phan hoi cho gateway thong qua uart
uart_putchar(0x81);
// check xem may bom co duoc bat khong?
// neu may bom dang tat thi bat may bom len
if(MAYBOM!=1) Maybom=1;
}
break;
// nhan duoc ban tin dieu khien van 2
case 0x82:
{
Van2=1; // bat van 2
//gui lai ban tin phan hoi cho gateway thong qua uart
uart_putchar(0x82);
// check xem may bom co duoc bat khong?
// neu may bom dang tat thi bat may bom len
if(MAYBOM!=1) Maybom=1 ;
}
break;
// nhan duoc ban tin dieu khien van 3
case 0x83:
{
Van3=1; // bat van 3
//gui lai ban tin phan hoi cho gateway thong qua uart
uart_putchar(0x83);
// check xem may bom co duoc bat khong?
// neu may bom dang tat thi bat may bom len
if(MAYBOM!=1) Maybom=1 ;
}
break;
// nhan duoc ban tin dieu khien van 4
case 0x84:
{
Van4=1; // bat van 4
//gui lai ban tin phan hoi cho gateway thong qua uart
uart_putchar(0x84);
// check xem may bom co duoc bat khong?
// neu may bom dang tat thi bat may bom len
if(MAYBOM!=1) Maybom=1 ;
}
break;
// nhan duoc ban tin dieu khien van 5
case 0x85:
{
Van5=1; // bat van 5
//gui lai ban tin phan hoi cho gateway thong qua uart
uart_putchar(0x85);
// check xem may bom co duoc bat khong?
// neu may bom dang tat thi bat may bom len
if(MAYBOM!=1) Maybom=1 ;
}
break;
// nhan duoc ban tin dieu khien van 6
// van 6 dung cho vuon tue
case 0x86:
{
Van6=1; // bat van 6
//gui lai ban tin phan hoi cho gateway thong qua uart
uart_putchar(0x86);
// check xem may bom co duoc bat khong?
// neu may bom dang tat thi bat may bom len
if(MAYBOM!=1) Maybom=1 ;
}
break;
// nhan duoc ban tin bat tat ca cac van
case 0x8F:
{
//gui lai ban tin phan hoi cho gateway thong qua uart
uart_putchar(0x8F);
on_all_van();
}
break;
// nhan duoc ban tin dieu khien tat van 1
case 0x01:
{
//gui lai ban tin phan hoi cho gateway thong qua uart
uart_putchar(0x01);
// check xem co con van nao duoc bat khong?
// neu nhu cac van tat het thi tat may bom
// sau do moi tat van duoc dieu khien
if(Van2==0&&Van3==0&&Van4==0&&Van5==0&&Van6==0)
{
Maybom=0;
// tre 1 khoang thoi gian roi moi tat van dieu khien
for(i=0;i<1000;i++);
}
Van1=0; // tat van 1
}
break;
// nhan duoc ban tin dieu khien tat van 2
case 0x02:
{
//gui lai ban tin phan hoi cho gateway thong qua uart
uart_putchar(0x02);
// check xem co con van nao duoc bat khong?
// neu nhu cac van tat het thi tat may bom
// sau do moi tat van duoc dieu khien
if(Van1==0&&Van3==0&&Van4==0&&Van5==0&&Van6==0)
{
Maybom=0;
// tre 1 khoang thoi gian roi moi tat van dieu khien
for(i=0;i<1000;i++);
}
Van2=0; // tat van 2
}
break;
// nhan duoc ban tin dieu khien tat van 3
case 0x03:
{
//gui lai ban tin phan hoi cho gateway thong qua uart
uart_putchar(0x03);
// check xem co con van nao duoc bat khong?
// neu nhu cac van tat het thi tat may bom
// sau do moi tat van duoc dieu khien
if(Van1==0&&Van2==0&&Van4==0&&Van5==0&&Van6==0)
{
Maybom=0;
// tre 1 khoang thoi gian roi moi tat van dieu khien
for(i=0;i<1000;i++);
}
Van3=0; // tat van 3
}
break;
// nhan duoc ban tin dieu khien tat van 4
case 0x04:
{
//gui lai ban tin phan hoi cho gateway thong qua uart
uart_putchar(0x04);
// check xem co con van nao duoc bat khong?
// neu nhu cac van tat het thi tat may bom
// sau do moi tat van duoc dieu khien
if(Van1==0&&Van2==0&&Van3==0&&Van5==0&&Van6==0)
{
Maybom=0;
// tre 1 khoang thoi gian roi moi tat van dieu khien
for(i=0;i<1000;i++);
}
Van4=0; // tat van 4
}
break;
// nhan duoc ban tin dieu khien tat van 5
case 0x05:
{
//gui lai ban tin phan hoi cho gateway thong qua uart
uart_putchar(0x05);
// check xem co con van nao duoc bat khong?
// neu nhu cac van tat het thi tat may bom
// sau do moi tat van duoc dieu khien
if(Van1==0&&Van2==0&&Van3==0&&Van4==0&&Van6==0)
{
Maybom=0;
// tre 1 khoang thoi gian roi moi tat van dieu khien
for(i=0;i<1000;i++);
}
Van5=0; // tat van 5
}
break;
// nhan duoc ban tin dieu khien tat van 6
case 0x06:
{
//gui lai ban tin phan hoi cho gateway thong qua uart
uart_putchar(0x06);
// check xem co con van nao duoc bat khong?
// neu nhu cac van tat het thi tat may bom
// sau do moi tat van duoc dieu khien
if(Van1==0&&Van2==0&&Van3==0&&Van4==0&&Van5==0)
{
Maybom=0;
// tre 1 khoang thoi gian roi moi tat van dieu khien
for(i=0;i<1000;i++);
Van6=0; // tat van 1
}
}
break;
// nhan duoc ban tin dieu khien tat het cac van
case 0x0F:
{
//gui lai ban tin phan hoi cho gateway thong qua uart
uart_putchar(0x0F);
off_all_van();
}
default:
break;
}
rx_data=0;
}
void gdb_end_packet() {
uart_putchar(ESP_GDB_FILENO, '#');
uart_putchar(ESP_GDB_FILENO, hexdigit(gdb_send_checksum >> 4));
uart_putchar(ESP_GDB_FILENO, hexdigit(gdb_send_checksum & 0xF));
}
void keyboard_read(int mode)
{
unsigned char c;
int release;
int extended;
ps2_enable();
play_note(6, "a", 4, 100);
release = 0;
extended = 0;
keyboard_mode = mode;
memset(key_map, 0, NUM_KEYS);
while(keyboard_mode) {
while(((c = ps2_read_char()) == 0) && keyboard_mode) { ; }
//scan code mode
if(keyboard_mode == KEYBOARD_SCAN) {
if(c == KEY_RELEASE) {
release = 1;
}
else if(release) {
key_map[c] = 0;
release = 0;
}
else if(!key_map[c]) {
key_map[c] = 1;
}
else {
continue;
}
uart_printf("0x%.2X ", (unsigned int)c);
}
//typing mode
else if(keyboard_mode == KEYBOARD_TYPE) {
if(c == KEY_RELEASE) {
release = 1;
continue;
}
else if(c == KEY_EXTENDED) {
extended = 1;
continue;
}
//key release
else if(release) {
key_map[c] = 0;
release = 0;
}
else {
key_map[c] = 1;
if(c == KEY_LSHIFT || c == KEY_RSHIFT) {
continue;
}
else if(c == KEY_CTRL) {
continue;
}
else if(c == KEY_ESCAPE) {
break;
}
else {
if(key_map[KEY_CTRL]) {
uart_printf("ctl-");
}
if(key_map[KEY_LSHIFT] || key_map[KEY_RSHIFT]) {
uart_putchar(scancode_shift_map[c]);
}
else {
uart_putchar(scancode_map[c]);
}
}
}
}
}
keyboard_disable();
}
void
out_char (char ch)
{
uart_putchar(FIRE_PORT, ch);
}
void uart_puts(char *str)
{
__uart_puts(str);
uart_putchar('\n');
uart_putchar('\r');
}
/*
* Gibt eine nullterminierte Zeichenkette aus dem Programmspeicher ueber
* die serielle Schnittstelle aus.
*
*/
void uart_puts_P(const char *s)
{
while(pgm_read_byte(s))
uart_putchar(pgm_read_byte(s++));
}
void
out_char (char ch)
{
uart_putchar(TERM_PORT, ch);
}
/** @brief Send a string via UART
*
* @param [in] uart The UART on which to send the string
* @param [in] string The string to send
*
* @return None.
*
* Uses uart_putchar, so this is will block until the entire string
* has been sent.
*/
void uart_putstr(UART_Type *uart, const char *string)
{
while (*string != '\0') {
uart_putchar(uart, (uint8_t)(*string++));
}
}
void uart_puts(char *str) {
for (uint8_t i = 0; str[i] != '\0'; i++)
uart_putchar(str[i]);
}
void uart_putchar(char c) {
if (c == '\n')
uart_putchar('\r');
loop_until_bit_is_set(UCSRA, UDRE); // wait for UDR empty
UDR = c; // send byte to UDR
}
/*
* the polling output of uart
*/
void
emstartkit_putc(DW_APB_UART_STRUCT_PTR regs, char_t c)
{
while (!uart_putready(regs));
uart_putchar(regs, c);
}
/*!
* @brief 重定义printf 到串口
* @param ch 需要打印的字节
* @param stream 数据流
* @since v5.0
* @note 此函数由编译器自带库里的printf所调用
*/
int fputc(int ch, FILE *stream)
{
uart_putchar(VCAN_PORT, (char)ch);
return(ch);
}
int putchar(char c)
{
uart_putchar(c);
return 0;
}
void putc ( void* p, char c) { uart_putchar(c); }
void Roomba_Stop()
{
uart_putchar(STOP);
}
/**
* Sends one character to the SOL payload
*/
void sol_send_char_to_payload(unsigned char ch)
{
/* print char to SOL UART interface*/
uart_putchar(SOL_UART, ch);
}
void Roomba_Clean()
{
uart_putchar(CLEAN);
}
/*
* Gibt eine nullterminierte Zeichenkette ueber die serielle Schnittstelle
* aus.
*
*/
void uart_puts(const char *s)
{
while(*s)
uart_putchar(*s++);
}
void Roomba_Finish() {
uart_putchar(STOP);
}
void uart_putdata(uint8_t *data, uint8_t count) {
int i;
led1_on();
for(i=0; i<count; i++) uart_putchar(data[i]);
led1_off();
}
void setServo(uint8_t servoId, uint8_t value) {
servopos[0] = value;
uart_putchar(value);
uart_putchar(-value);
uart_putchar(0);
}
/*
* Receive a character from the UART Rx.
*
* This features a simple line-editor that allows to delete and
* re-edit the characters entered, until either CR or NL is entered.
* Printable characters entered will be echoed using uart_putchar().
*
* Editing characters:
*
* . \b (BS) or \177 (DEL) delete the previous character
* . ^u kills the entire input buffer
* . ^w deletes the previous word
* . ^r sends a CR, and then reprints the buffer
* . \t will be replaced by a single space
*
* All other control characters will be ignored.
*
* The internal line buffer is RX_BUFSIZE (80) characters long, which
* includes the terminating \n (but no terminating \0). If the buffer
* is full (i. e., at RX_BUFSIZE-1 characters in order to keep space for
* the trailing \n), any further input attempts will send a \a to
* uart_putchar() (BEL character), although line editing is still
* allowed.
*
* Input errors while talking to the UART will cause an immediate
* return of -1 (error indication). Notably, this will be caused by a
* framing error (e. g. serial line "break" condition), by an input
* overrun, and by a parity error (if parity was enabled and automatic
* parity recognition is supported by hardware).
*
* Successive calls to uart_getchar() will be satisfied from the
* internal buffer until that buffer is emptied again.
*/
int
uart_getchar(FILE *stream)
{
uint8_t c;
char *cp, *cp2;
static char b[RX_BUFSIZE];
static char *rxp;
if (rxp == 0)
for (cp = b;;)
{
loop_until_bit_is_set(UCSRA, RXC);
if (UCSRA & _BV(FE))
return _FDEV_EOF;
if (UCSRA & _BV(DOR))
return _FDEV_ERR;
c = UDR;
/* behaviour similar to Unix stty ICRNL */
if (c == '\r')
c = '\n';
if (c == '\n')
{
*cp = c;
uart_putchar(c, stream);
rxp = b;
break;
}
else if (c == '\t')
c = ' ';
if ((c >= (uint8_t)' ' && c <= (uint8_t)'\x7e') ||
c >= (uint8_t)'\xa0')
{
if (cp == b + RX_BUFSIZE - 1)
uart_putchar('\a', stream);
else
{
*cp++ = c;
uart_putchar(c, stream);
}
continue;
}
switch (c)
{
case 'c' & 0x1f:
return -1;
case '\b':
case '\x7f':
if (cp > b)
{
uart_putchar('\b', stream);
uart_putchar(' ', stream);
uart_putchar('\b', stream);
cp--;
}
break;
case 'r' & 0x1f:
uart_putchar('\r', stream);
for (cp2 = b; cp2 < cp; cp2++)
uart_putchar(*cp2, stream);
break;
case 'u' & 0x1f:
while (cp > b)
{
uart_putchar('\b', stream);
uart_putchar(' ', stream);
uart_putchar('\b', stream);
cp--;
}
break;
case 'w' & 0x1f:
while (cp > b && cp[-1] != ' ')
{
uart_putchar('\b', stream);
uart_putchar(' ', stream);
uart_putchar('\b', stream);
cp--;
}
break;
}
}
c = *rxp++;
if (c == '\n')
rxp = 0;
return c;
}
void getServo(uint8_t servoId) {
uint8_t value = servopos[servoId-1];
uart_putchar(value);
uart_putchar(-value);
uart_putchar(0);
}
int uart_puts(const char *s) {
int cnt = 0;
while (*s && !uart_putchar(*s++)) cnt++;
return cnt;
}
static int uart_putchar(char c, FILE *stream)
{
if (c == '\n')
uart_putchar('\r', stream);
USART_Transmit(c);
}
// Send a string in PROGMEM to the UART
void uart_putstring_P(const char *buffer)
{
// start sending characters over the serial port until we reach the end of the string
while (pgm_read_byte(buffer) != '\0') // are we done yet?
uart_putchar(pgm_read_byte(buffer++)); // read byte from PROGMEM and send it
}
int
uart_getchar(FILE *stream)
{
uint8_t c;
char *cp, *cp2;
static char b[RX_BUFSIZE];
static char *rxp;
if (rxp == 0)
for (cp = b;;)
{
// --- trtWait added instead of loop_until wait
trtWait(SEM_RX_ISR_SIGNAL) ; //loop_until_bit_is_set(UCSR0A, RXC0)
if (UCSR0A & _BV(FE0))
return _FDEV_EOF;
if (UCSR0A & _BV(DOR0))
return _FDEV_ERR;
// -- added to take char from ISR ---
c = trt_rx_c ; //c = UDR0; -- CHANGED
/* behaviour similar to Unix stty ICRNL */
if (c == '\r')
c = '\n';
if (c == '\n')
{
*cp = c;
uart_putchar(c, stream);
rxp = b;
// --- added for TRT to signal string-end
trtSignal(SEM_STRING_DONE); //added--to signal end of string
break;
}
else if (c == '\t')
c = ' ';
if ((c >= (uint8_t)' ' && c <= (uint8_t)'\x7e') ||
c >= (uint8_t)'\xa0')
{
if (cp == b + RX_BUFSIZE - 1)
uart_putchar('\a', stream);
else
{
*cp++ = c;
uart_putchar(c, stream);
}
continue;
}
switch (c)
{
case 'c' & 0x1f:
return -1;
case '\b':
case '\x7f':
if (cp > b)
{
uart_putchar('\b', stream);
uart_putchar(' ', stream);
uart_putchar('\b', stream);
cp--;
}
break;
case 'r' & 0x1f:
uart_putchar('\r', stream);
for (cp2 = b; cp2 < cp; cp2++)
uart_putchar(*cp2, stream);
break;
case 'u' & 0x1f:
while (cp > b)
{
uart_putchar('\b', stream);
uart_putchar(' ', stream);
uart_putchar('\b', stream);
cp--;
}
break;
case 'w' & 0x1f:
while (cp > b && cp[-1] != ' ')
{
uart_putchar('\b', stream);
uart_putchar(' ', stream);
uart_putchar('\b', stream);
cp--;
}
break;
}
}
c = *rxp++;
if (c == '\n')
rxp = 0;
return c;
}
void gdb_putchar(char ch) {
gdb_send_checksum += (uint8_t) ch;
uart_putchar(ESP_GDB_FILENO, ch);
}
void
uart_puts(int offset, const char *s)
{
while (*s != '\0')
uart_putchar(offset, *s++);
}
