Blocking and non-blocking operation of Linux under serial port

There are two ports that can be controlled for serial blocking (simultaneous control of Read and write): One is the opening of the serial port, whether the open function with O_ndelay, the second one can be opened after the serial port through the FCNTL () function to control.

Definition of blocking:

For Read,block refers to when the serial input buffer does not have data, the read function will be blocked here, ported to the serial input buffer data can be read, read to the required number of bytes, the return value is read to the number of bytes;

For Write,block when the serial output buffer is full, or the remaining space is less than the number of bytes to be written, write will block until the remaining space in the serial output buffer is greater than or equal to the number of bytes to be written, and the write operation returns the number of bytes written.

Non-blocking definitions:

For Read,no block, when there is no data for the serial input buffer, the Read function returns immediately and the return value is 0.

For Write,no block, when the serial output buffer is full, or the remaining space is less than the number of bytes to be written, write writes the number of bytes allowed in the remaining space of the current serial output buffer, and then returns the number of bytes written.

[CPP]View Plaincopy

2. static int set_opt (int fd, int nspeed, int nBits, char nevent, int nstop)
4. {
6. struct Termios newtio;
8. struct Termios oldtio;
12. if (tcgetattr (fd,&oldtio)! = 0)
14. {
16. Perror ("Setupserial 1");
18. return-1;
20. }
24. Bzero (&newtio,sizeof (newtio));
26. Newtio.c_cflag |= clocal | Cread;
28. Newtio.c_cflag &= ~csize;
32. /*********** Data bit selection ****************/
34. switch (nBits)
36. {
38. Case 7:
40. Newtio.c_cflag |= CS7;
42. Break ;
44. Case 8:
46. Newtio.c_cflag |= CS8;
48. Break ;
50. }
52. /*********** Check bit selection ****************/
54. switch (nevent)
56. {
58. case ' O ':
60. Newtio.c_cflag |= Parenb;
62. Newtio.c_cflag |= parodd;
64. Newtio.c_iflag |= (INPCK | Istrip);
66. Break ;
68. case ' E ':
70. Newtio.c_iflag |= (INPCK | Istrip);
72. Newtio.c_cflag |= Parenb;
74. Newtio.c_cflag &= ~parodd;
76. Break ;
78. case ' N ':
80. Newtio.c_cflag &= ~parenb;
82. Break ;
84. }
86. /*********** Baud Rate Selection ****************/
88. switch (nspeed)
90. {
92. Case 2400:
94. Cfsetispeed (&newtio,b2400);
96. Cfsetospeed (&newtio,b2400);
98. Break ;
100. Case 4800:
102. Cfsetispeed (&newtio,b4800);
104. Cfsetospeed (&newtio,b4800);
106. Break ;
108. Case 9600:
110. Cfsetispeed (&newtio,b9600);
112. Cfsetospeed (&newtio,b9600);
114. Break ;
116. Case 57600:
118. Cfsetispeed (&newtio,b57600);
120. Cfsetospeed (&newtio,b57600);
122. Break ;
124. Case 115200:
126. Cfsetispeed (&newtio,b115200);
128. Cfsetospeed (&newtio,b115200);
130. Break ;
132. Case 460800:
134. Cfsetispeed (&newtio,b460800);
136. Cfsetospeed (&newtio,b460800);
138. Break ;
140. Default:
142. Cfsetispeed (&newtio,b9600);
144. Cfsetospeed (&newtio,b9600);
146. Break ;
148. }
150. /*********** Stop bit selection ****************/
152. if (nstop = = 1) {
154. Newtio.c_cflag &= ~CSTOPB;
156. }
158. Else if (nstop ==2) {
160. Newtio.c_cflag |= CSTOPB;
162. }
164. Newtio.c_cc[vtime] = 1;
166. Newtio.c_cc[vmin] = frame_maxsize; //Effective under blocking conditions
170. Tcflush (Fd,tciflush);
172. if ((Tcsetattr (fd,tcsanow,&newtio))! = 0)
174. {
176. perror ("com set error");
178. return-1;
180. }
182. printf ("set done!\n");
184. return 0;
186. }

[CPP]View Plaincopy

2. static int open_port (int fd,int comport)
4. {
6. /*********** Open Serial 1****************/
8. if (comport = = 1)
10. {
12. FD = open ("/DEV/TTYAT1", o_rdwr| o_noctty|     O_ndelay);
14. if (fd = =-1) {
16. Perror ("Can ' t Open Serial Port");
18. return-1;
20. }
22. }
24. /*********** Open Serial 2****************/
26. Else if (comport = = 2)
28. {
30. FD = open ("/dev/ttyat2", o_rdwr| o_noctty|     O_ndelay);
32. if (fd = =-1) {
34. Perror ("Can ' t Open Serial Port");
36. return-1;
38. }
40. }
42. /*********** Open Serial 3****************/
44. Else if (comport = = 3)
46. {
48. FD = open ("/DEV/TTYAT3", o_rdwr| o_noctty|     O_ndelay);
50. if (fd = =-1) {
52. Perror ("Can ' t Open Serial Port");
54. return-1;
56. }
58. }
60. if (comport = = 1)
62. {
64. if (fcntl (Fd,f_setfl,fndelay) < 0)//non-blocking, overwrite the properties of the previous open
66. {
68. printf ("Fcntl failed\n");
70. }
72. else{
74. printf ("fcntl=%d\n", Fcntl (Fd,f_setfl,fndelay));
76. }
78. }
80. Else
82. {
84. if (fcntl (fd,f_setfl,0) < 0) { //block, even if the front of the open serial device is set to be non-blocking, this is set to block, whichever is
86. printf ("Fcntl failed\n");
88. }
90. else{
92. printf ("fcntl=%d\n", Fcntl (fd,f_setfl,0));
94. }
96. }
98. if (isatty (stdin_fileno) = = 0) {
102. printf ("standard input was not a terminal device\n");
104. }
106. else{
110. printf ("Isatty sucess!\n");
112. }
116. printf ("fd-open=%d\n", FD);
118. return FD;
120. }

Therefore, the blocking of the serial port of Linux is set by the Fcntl () function.

[CPP]View Plaincopy

1. Blocking: Fcntl (fd,f_setfl,0)

[CPP]View Plaincopy

1. Non-blocking: Fcntl (Fd,f_setfl,fndelay)

Blocking and non-blocking operation of Linux under serial port