UART string issue : string data missing

Robotics & Edge Computing Jetson Systems Jetson TK1
1

Hello everyone , I am using serial port to transmit data between tk1 and PC , and encountered some problems.

It works fine when I send string data from tk1 to PC, but from PC to tk1,only a few characters are received. For example, when I send “hello world” from PC to tk1, only ‘h’, ‘l’ are received.

I try both ttyTHS0 and ttyTHS1,and USB to RS232, and got the same result.

My code are as follows:
send.cpp

#include<stdio.h>    
#include<stdlib.h>     
#include<unistd.h>     
#include<sys/types.h>  
#include<sys/stat.h>   
#include<fcntl.h>     
#include<termios.h>   
#include<errno.h>    
#include<string.h>

/** 
 * open port 
 * @param  fd 
 * @param  comport  the port you want to open
 * @return  -1 means fail to open 
 */  
int open_port(int fd,int comport)   
{   
    char *dev[]={"/dev/ttyUSB0","/dev/ttyS1","/dev/ttyS2"};  
  
    if (comport==1)// serial port1  
    {  
        fd = open( "/dev/ttyUSB0", O_RDWR|O_NOCTTY|O_NDELAY);   
        if (-1 == fd)  
        {   
            perror("Can't Open Serial Port");   
            return(-1);   
        }   
     }   
     else if(comport==2)//serial port2  
     {       
        fd = open( "/dev/ttyS1", O_RDWR|O_NOCTTY|O_NDELAY); 
  
        if (-1 == fd)  
        {   
            perror("Can't Open Serial Port");   
            return(-1);   
        }   
     }   
     else if (comport==3)//serial port 3   
     {   
        fd = open( "/dev/ttyS2", O_RDWR|O_NOCTTY|O_NDELAY);   
        if (-1 == fd)  
        {   
            perror("Can't Open Serial Port");   
            return(-1);   
        }   
     }   
   
     if(fcntl(fd, F_SETFL, 0)<0)   
            printf("fcntl failed!\n");   
     else   
        printf("fcntl=%d\n",fcntl(fd, F_SETFL,0));   
  
     if(isatty(STDIN_FILENO)==0)   
        printf("standard input is not a terminal device\n");   
     else   
        printf("isatty success!\n");   
     printf("fd-open=%d\n",fd);   
     return fd;   
}  


 int set_opt(int fd,int nSpeed, int nBits, char nEvent, int nStop)   
{   
     struct termios newtio,oldtio;   
 
     if  ( tcgetattr( fd,&oldtio)  !=  0) {    
      perror("SetupSerial 1");  
    printf("tcgetattr( fd,&oldtio) -> %d\n",tcgetattr( fd,&oldtio));   
      return -1;   
     }   
     bzero( &newtio, sizeof( newtio ) );   
   
     newtio.c_cflag  |=  CLOCAL | CREAD;    
     newtio.c_cflag &= ~CSIZE;    
 
     switch( nBits )   
     {   
     case 7:   
      newtio.c_cflag |= CS7;   
      break;   
     case 8:   
      newtio.c_cflag |= CS8;   
      break;   
     }   

     switch( nEvent )   
     {   
     case 'o':  
     case 'O':   
      newtio.c_cflag |= PARENB;   
      newtio.c_cflag |= PARODD;   
      newtio.c_iflag |= (INPCK | ISTRIP);   
      break;   
     case 'e':  
     case 'E':   
      newtio.c_iflag |= (INPCK | ISTRIP);   
      newtio.c_cflag |= PARENB;   
      newtio.c_cflag &= ~PARODD;   
      break;  
     case 'n':  
     case 'N':     
      newtio.c_cflag &= ~PARENB;   
      break;  
     default:  
      break;  
     }   
       
switch( nSpeed )   
     {   
     case 2400:   
      cfsetispeed(&newtio, B2400);   
      cfsetospeed(&newtio, B2400);   
      break;   
     case 4800:   
      cfsetispeed(&newtio, B4800);   
      cfsetospeed(&newtio, B4800);   
      break;   
     case 9600:   
      cfsetispeed(&newtio, B9600);   
      cfsetospeed(&newtio, B9600);   
      break;   
     case 115200:   
      cfsetispeed(&newtio, B115200);   
      cfsetospeed(&newtio, B115200);   
      break;   
     case 460800:   
      cfsetispeed(&newtio, B460800);   
      cfsetospeed(&newtio, B460800);   
      break;   
     default:   
      cfsetispeed(&newtio, B9600);   
      cfsetospeed(&newtio, B9600);   
     break;   
     }   
 
     if( nStop == 1 )   
      newtio.c_cflag &=  ~CSTOPB;   
     else if ( nStop == 2 )   
      newtio.c_cflag |=  CSTOPB;   

     newtio.c_cc[VTIME]  = 0;   
     newtio.c_cc[VMIN] = 0;   
   
     tcflush(fd,TCIFLUSH);   

if((tcsetattr(fd,TCSANOW,&newtio))!=0)   
     {   
      perror("com set error");   
      return -1;   
     }   
     printf("set done!\n");   
     return 0;   
}   

int main(int argc, char **argv){
	int fd;
	int nread;
	char buff1[512]="hello world 1";
        char buff2[512]="hello world 2";
        char buff3[512]="hello world 3";
	char *dev  = "/dev/ttyUSB0"; 
	fd = open_port(fd,1);
	int set_option=set_opt(fd,9600,8,'E',1);
	if(!set_option){
		perror("read STDIN_FILENO"); 
		}
	       
	int len1=write(fd,buff1,512);
        int len2=write(fd,buff2,512);
        int len3=write(fd,buff3,512);
	//close(fd);  
	// exit (0);
}

receive.cpp

#include<stdio.h>      
#include<stdlib.h>     
#include<unistd.h>   
#include<sys/types.h>  
#include<sys/stat.h>   
#include<fcntl.h>    
#include<termios.h>   
#include<errno.h>    



int open_port(int fd,int comport)   
{   
    char *dev[]={"/dev/ttyUSB0","/dev/ttyS1","/dev/ttyS2"};  
  
    if (comport==1)
    {  
        fd = open( "/dev/ttyUSB0", O_RDWR|O_NOCTTY|O_NDELAY);   
        if (-1 == fd)  
        {   
            perror("Can't Open Serial Port");   
            return(-1);   
        }   
     }   
     else if(comport==2)  
     {       
        fd = open( "/dev/ttyS1", O_RDWR|O_NOCTTY|O_NDELAY);
        if (-1 == fd)  
        {   
            perror("Can't Open Serial Port");   
            return(-1);   
        }   
     }   
     else if (comport==3)
     {   
        fd = open( "/dev/ttyS2", O_RDWR|O_NOCTTY|O_NDELAY);   
        if (-1 == fd)  
        {   
            perror("Can't Open Serial Port");   
            return(-1);   
        }   
     }   
  
     if(fcntl(fd, F_SETFL, 0)<0)   
            printf("fcntl failed!\n");   
     else   
        printf("fcntl=%d\n",fcntl(fd, F_SETFL,0));   
     
     if(isatty(STDIN_FILENO)==0)   
        printf("standard input is not a terminal device\n");   
     else   
        printf("isatty success!\n");   
     printf("fd-open=%d\n",fd);   
     return fd;   
}  


 int set_opt(int fd,int nSpeed, int nBits, char nEvent, int nStop)   
{   
     struct termios newtio,oldtio;   
   
     if  ( tcgetattr( fd,&oldtio)  !=  0) {    
      perror("SetupSerial 1");  
    printf("tcgetattr( fd,&oldtio) -> %d\n",tcgetattr( fd,&oldtio));   
      return -1;   
     }   
     bzero( &newtio, sizeof( newtio ) );   

     newtio.c_cflag  |=  CLOCAL | CREAD;    
     newtio.c_cflag &= ~CSIZE;    
  
     switch( nBits )   
     {   
     case 7:   
      newtio.c_cflag |= CS7;   
      break;   
     case 8:   
      newtio.c_cflag |= CS8;   
      break;   
     }   
  
     switch( nEvent )   
     {   
     case 'o':  
     case 'O':   
      newtio.c_cflag |= PARENB;   
      newtio.c_cflag |= PARODD;   
      newtio.c_iflag |= (INPCK | ISTRIP);   
      break;   
     case 'e':  
     case 'E':   
      newtio.c_iflag |= (INPCK | ISTRIP);   
      newtio.c_cflag |= PARENB;   
      newtio.c_cflag &= ~PARODD;   
      break;  
     case 'n':  
     case 'N':
      newtio.c_cflag &= ~PARENB;   
      break;  
     default:  
      break;  
     }   
    
switch( nSpeed )   
     {   
     case 2400:   
      cfsetispeed(&newtio, B2400);   
      cfsetospeed(&newtio, B2400);   
      break;   
     case 4800:   
      cfsetispeed(&newtio, B4800);   
      cfsetospeed(&newtio, B4800);   
      break;   
     case 9600:   
      cfsetispeed(&newtio, B9600);   
      cfsetospeed(&newtio, B9600);   
      break;   
     case 115200:   
      cfsetispeed(&newtio, B115200);   
      cfsetospeed(&newtio, B115200);   
      break;   
     case 460800:   
      cfsetispeed(&newtio, B460800);   
      cfsetospeed(&newtio, B460800);   
      break;   
     default:   
      cfsetispeed(&newtio, B9600);   
      cfsetospeed(&newtio, B9600);   
     break;   
     }   
  
     if( nStop == 1 )   
      newtio.c_cflag &=  ~CSTOPB;   
     else if ( nStop == 2 )   
      newtio.c_cflag |=  CSTOPB;   

     newtio.c_cc[VTIME]  = 0;   
     newtio.c_cc[VMIN] = 0;   

     tcflush(fd,TCIFLUSH);   
  
if((tcsetattr(fd,TCSANOW,&newtio))!=0)   
     {   
      perror("com set error");   
      return -1;   
     }   
     printf("set done!\n");   
     return 0;   
}   

int main(int argc, char **argv){
	int fd;
	int nread;
	char buff[512];
	char *dev  = "/dev/ttyUSB0"; 
	fd = open_port(fd,1);
	int set_option=set_opt(fd,9600,8,'E',1);
	if(!set_option){
		perror("read STDIN_FILENO"); 
		}
	
while (1) //  keep reading data
{   
	while((nread = read(fd, buff, 512))>0)
	{ 
		//if(nread)printf("read success!");
                //printf("\nLen %d\n",nread); 
		//buff[nread+1] = '

#include<stdio.h>
#include<stdlib.h>
#include<unistd.h>
#include<sys/types.h>
#include<sys/stat.h>
#include<fcntl.h>
#include<termios.h>
#include<errno.h>

int open_port(int fd,int comport)
{
char *dev={“/dev/ttyUSB0”,“/dev/ttyS1”,“/dev/ttyS2”};

if (comport==1)
{  
    fd = open( "/dev/ttyUSB0", O_RDWR|O_NOCTTY|O_NDELAY);   
    if (-1 == fd)  
    {   
        perror("Can't Open Serial Port");   
        return(-1);   
    }   
 }   
 else if(comport==2)  
 {       
    fd = open( "/dev/ttyS1", O_RDWR|O_NOCTTY|O_NDELAY);
    if (-1 == fd)  
    {   
        perror("Can't Open Serial Port");   
        return(-1);   
    }   
 }   
 else if (comport==3)
 {   
    fd = open( "/dev/ttyS2", O_RDWR|O_NOCTTY|O_NDELAY);   
    if (-1 == fd)  
    {   
        perror("Can't Open Serial Port");   
        return(-1);   
    }   
 }   

 if(fcntl(fd, F_SETFL, 0)<0)   
        printf("fcntl failed!\n");   
 else   
    printf("fcntl=%d\n",fcntl(fd, F_SETFL,0));   
 
 if(isatty(STDIN_FILENO)==0)   
    printf("standard input is not a terminal device\n");   
 else   
    printf("isatty success!\n");   
 printf("fd-open=%d\n",fd);   
 return fd;

}

int set_opt(int fd,int nSpeed, int nBits, char nEvent, int nStop)
{
struct termios newtio,oldtio;

 if  ( tcgetattr( fd,&oldtio)  !=  0) {    
  perror("SetupSerial 1");  
printf("tcgetattr( fd,&oldtio) -> %d\n",tcgetattr( fd,&oldtio));   
  return -1;   
 }   
 bzero( &newtio, sizeof( newtio ) );   

 newtio.c_cflag  |=  CLOCAL | CREAD;    
 newtio.c_cflag &= ~CSIZE;    

 switch( nBits )   
 {   
 case 7:   
  newtio.c_cflag |= CS7;   
  break;   
 case 8:   
  newtio.c_cflag |= CS8;   
  break;   
 }   

 switch( nEvent )   
 {   
 case 'o':  
 case 'O':   
  newtio.c_cflag |= PARENB;   
  newtio.c_cflag |= PARODD;   
  newtio.c_iflag |= (INPCK | ISTRIP);   
  break;   
 case 'e':  
 case 'E':   
  newtio.c_iflag |= (INPCK | ISTRIP);   
  newtio.c_cflag |= PARENB;   
  newtio.c_cflag &= ~PARODD;   
  break;  
 case 'n':  
 case 'N':
  newtio.c_cflag &= ~PARENB;   
  break;  
 default:  
  break;  
 }

switch( nSpeed )
{
case 2400:
cfsetispeed(&newtio, B2400);
cfsetospeed(&newtio, B2400);
break;
case 4800:
cfsetispeed(&newtio, B4800);
cfsetospeed(&newtio, B4800);
break;
case 9600:
cfsetispeed(&newtio, B9600);
cfsetospeed(&newtio, B9600);
break;
case 115200:
cfsetispeed(&newtio, B115200);
cfsetospeed(&newtio, B115200);
break;
case 460800:
cfsetispeed(&newtio, B460800);
cfsetospeed(&newtio, B460800);
break;
default:
cfsetispeed(&newtio, B9600);
cfsetospeed(&newtio, B9600);
break;
}

 if( nStop == 1 )   
  newtio.c_cflag &=  ~CSTOPB;   
 else if ( nStop == 2 )   
  newtio.c_cflag |=  CSTOPB;   

 newtio.c_cc[VTIME]  = 0;   
 newtio.c_cc[VMIN] = 0;   

 tcflush(fd,TCIFLUSH);

if((tcsetattr(fd,TCSANOW,&newtio))!=0)
{
perror(“com set error”);
return -1;
}
printf(“set done!\n”);
return 0;
}

int main(int argc, char **argv){
int fd;
int nread;
char buff[512];
char *dev = “/dev/ttyUSB0”;
fd = open_port(fd,1);
int set_option=set_opt(fd,9600,8,‘E’,1);
if(!set_option){
perror(“read STDIN_FILENO”);
}

while (1) // keep reading data
{
while((nread = read(fd, buff, 512))>0)
{
//if(nread)printf(“read success!”);
//printf(“\nLen %d\n”,nread);
//buff[nread+1] = ‘\0’;
printf( “\n%s”, buff);
}
}
//close(fd);
// exit (0);
}

';   
		printf( "\n%s", buff);   
	}
}
	//close(fd);  
	// exit (0);
}

how can I solve this problem ? or can anyone provide some example that works?

Thanks in advance!

2

Check that you have correct serial config : by default TK1 is framing 115200 8 N 1 with HW flow control (CTS/RTS).

If not working, I would suggest trying another null-modem cable (full-wired, not a custom made one with 3 wires only).

In some cases, especially if you are using a USB-serial adapter, it may be a driver config issue. If possible, try to connect to a true serial port on host.

3

If the above mentioned CTS/RTS is used, then it should get everything through. Also, when serial UARTs are used, the built-in character buffer can be quite small…perhaps flushing at the correct moment might add reliability.

4

Thanks! It seems that USB-serial adapter driver do have influence on it. I can now send .txt files to PC through USB-serial adapter with driver CH340, but PL2303 didn’t work.

I only use +5v,GND,RXD and TXD four pins ,because I need to connect it to a serial-to-can module.So it might be not possible to add HW flow control.

Now the problem is that the file sent to PC is correct,but from PC to tk1 got garbled. I’ve checked baud rate and other basic settings on both side.

5

Now I change the code to write one character from the file to the port each time,and read 512 character each time. I am not sure is that flush at the correct moment?

6

It’s just a suggestion that if some part of the program writes and then doesn’t flush perhaps you’re running into simple buffer issues. You might take a look at something like O_SYNC on the open() call.

7

@_@

I set no parity then the garble problem solved.

8

A setting issue like parity would indeed be an issue. If you had to set no parity it means the other end defaulted to this. Possibly you could set parity on both ends and have it work again. Defaults on most serial ports are 8N1, so this does not surprise me at all.