读取USB串行数据时遇到问题

Question

I tried to read data from a USB adapter (PL2303) using this code.

My USB chip's spec is 57600, No parity, 1 Stop Bits, 8 bit data mode

I can get some wave data from buf[], but I don't know what these number means.

3, -1225386821, 0, 0, 1934713408, 6, 400, 520192, 45826, 0, 15971, 0, 2, -1091179996, 3, -1226244648, -1225242284, -1227820936, 524408, 2, 45826, 0, 0, 15971, 33188

Is this Hexa or something?

How do I get meaningful data from this? Is there any problem in my c++ code?

int open_port(void)
{
    int fd;
    fd=open("/dev/ttyUSB0", O_RDWR|O_NOCTTY|O_NDELAY);

    if(fd==-1)
    {
        fprintf(stderr, "open_port: Unable to open - %s\n", strerror(errno));
    }
    return (fd);
}

This code is used in Linux.

int main()
{
    int mainfd=0,fd;
    //char chout;
    int buf[5000];    
    struct termios options;
    FILE *pFile;
    pFile = fopen("rawdata.txt","w+");

    mainfd=open_port();
    fcntl(mainfd, F_SETFL, FNDELAY);

    tcgetattr(mainfd, &options);
    cfsetispeed(&options, B57600);
    cfsetospeed(&options, B57600);

    options.c_cflag |= (CLOCAL/CREAD);
    options.c_cflag &= PARENB;
    options.c_cflag &= ~CSTOPB;
    options.c_cflag &= ~CSIZE;
    options.c_cflag &= CS8;
    options.c_cflag &= ~CRTSCTS;

    options.c_cflag &= ~(ICANON | ECHO | ISIG);


    read(mainfd, buf, 5000);

    for(int i=0;i<5000;i++)     
    {
        cout<<buf[i]<<endl;

        fprintf(pFile,"%d\n",buf[i]);

    }    
    return 0;
}

Answer 1

Is this Hexa or something?

If you mean hexadecimal, then no.

How do I get meaningful data from this?

First you have to write your program to match that data that is received (eg bytes versus words, text versus binary), and then your program needs to keep track of what is actual received data versus uninitialized memory.

Is there any problem in my c++ code?

Yes, there are several significant problems with your code.

1. Your program uses nonblocking mode.

    fd=open("/dev/ttyUSB0", O_RDWR|O_NOCTTY|O_NDELAY);  
    ...
    fcntl(mainfd, F_SETFL, FNDELAY);

The open() uses the O_NDELAY option, and then the program redundantly ensures that nonblocking mode is active with the fcntl() call.
Nonblocking mode can be a valid method of performing I/O, but your program clearly does not implement the techniques to handle the additional complexities.

You would be better off by accessing the serial terminal in blocking mode.
Simply recode the fcntl() call to:

    fcntl(mainfd, F_SETFL, 0);

---

2. The termios initialization has errors and is incomplete .

The following two statements are ambiguous termios operations:

options.c_cflag &= PARENB;
options.c_cflag &= CS8;

Both statements simply preserve the existing state of those attributes. But you don't know what that existing state is, and worse you don't know whether the resulting state will be the attribute state that you require.

The following statement is erroneous because those termios attributes do not exist in the c_cflag structure member:

options.c_cflag &= ~(ICANON | ECHO | ISIG);

The termios initialization that attempts non-canonical mode is incomplete. The program leaves several other attributes unmodified (eg VMIN and VTIME), and therefore read behavior can be unpredictable.

3. The termios settings are never applied.

Your program is missing a call to tcsetattr() so that the new termios settings are actually applied.

4. The return code from the read() syscall is never evaluated.

The return code from the following syscall is ignored:

   read(mainfd, buf, 5000);  

As a consequence your program is unable to detect if any error has occurred.
If the read was successful, then your program is unaware how much data was returned (if any).

5. The program is accessing uninitialized memory.

Your program unconditionally processes the entire array of 5000 elements of an integer array.
However, per the semantics of the read() syscall, a maximum of 5000 bytes (rather than array elements or integers) has been specified, and the syscall may (and most likely will) return even less data than that maximum.
Instead of blindly processing the entire array, the program should only access the number of bytes (as indicated by a positive read() return code) actually stored in the buffer.

Whether the received data should be treated as signed integers rather than as unsigned bytes is questionable. Since read() is not guaranteed nor likely to return an integral number of sizeof(int) bytes, blindly handling the received data as integers is probably incorrect. You neglect to describe what this data represents other than a mention of " wave ".

Answer 2

As @πάτα ῥεῖ commented, the problem is that the buffer is declared int .

Please change the int in int buf [5000]; to unsigned char or uint8_t .