【imx6ul】linux下rs485的使用

0、说明

        对于linux下的485使用，其实就是linux下的串口使用。但是485有一个控制信号，在485等待接收的时候，控制信号需要时低电平，在发送的时候需要为高电平。所以对于linux下485驱动，最主要的任务就是完的成对控制信号电平的操作。

        该控制信号就是485芯片的2/3号引脚。

 1、485测试程序及改进过程

       如下demo程序，其实大部分代码是一个串口的程序。主要关注一下如下的rs485_enable函数。该函数通过ioctl的方式配置了使能参数。

1. #include <stdio.h>

2. #include <termios.h>

3. #include <linux/ioctl.h>

4. #include <linux/serial.h>

5. #include <asm-generic/ioctls.h> /* TIOCGRS485 + TIOCSRS485 ioctl definitions */

6. #include <unistd.h>

7. #include <errno.h>

8. #include <fcntl.h>

9. #include <sys/types.h>

10. #include <sys/stat.h>

11. #include <string.h>

12. #include <stdlib.h>

13. #include <getopt.h>

15. /**

16. * @brief: set the properties of serial port

17. * @Param: fd: file descriptor

18. * @Param: nSpeed: Baud Rate

19. * @Param: nBits: character size

20. * @Param: nEvent: parity of serial port

21. * @Param: nStop: stop bits

22. */

24. typedef enum {DISABLE = 0, ENABLE} RS485_ENABLE_t;

26. int set_port(int fd, int nSpeed, int nBits, char nEvent, int nStop)

27. {

28. struct termios newtio, oldtio;

30. memset(&oldtio, 0, sizeof(oldtio));

31. /* save the old serial port configuration */

32. if(tcgetattr(fd, &oldtio) != 0) {

33. perror("set_port/tcgetattr");

34. return -1;

35. }

37. memset(&newtio, 0, sizeof(newtio));

38. /* ignore modem control lines and enable receiver */

39. newtio.c_cflag = newtio.c_cflag |= CLOCAL | CREAD;

40. newtio.c_cflag &= ~CSIZE;

41. /* set character size */

42. switch (nBits) {

43. case 8:

44. newtio.c_cflag |= CS8;

45. break;

46. case 7:

47. newtio.c_cflag |= CS7;

48. break;

49. case 6:

50. newtio.c_cflag |= CS6;

51. break;

52. case 5:

53. newtio.c_cflag |= CS5;

54. break;

55. default:

56. newtio.c_cflag |= CS8;

57. break;

58. }

59. /* set the parity */

60. switch (nEvent) {

61. case 'o':

62. case 'O':

63. newtio.c_cflag |= PARENB;

64. newtio.c_cflag |= PARODD;

65. newtio.c_iflag |= (INPCK | ISTRIP);

66. break;

67. case 'e':

68. case 'E':

69. newtio.c_cflag |= PARENB;

70. newtio.c_cflag &= ~PARODD;

71. newtio.c_iflag |= (INPCK | ISTRIP);

72. break;

73. case 'n':

74. case 'N':

75. newtio.c_cflag &= ~PARENB;

76. break;

77. default:

78. newtio.c_cflag &= ~PARENB;

79. break;

80. }

81. /* set the stop bits */

82. switch (nStop) {

83. case 1:

84. newtio.c_cflag &= ~CSTOPB;

85. break;

86. case 2:

87. newtio.c_cflag |= CSTOPB;

88. break;

89. default:

90. newtio.c_cflag &= ~CSTOPB;

91. break;

92. }

93. /* set output and input baud rate */

94. switch (nSpeed) {

95. case 0:

96. cfsetospeed(&newtio, B0);

97. cfsetispeed(&newtio, B0);

98. break;

99. case 50:

100. cfsetospeed(&newtio, B50);

101. cfsetispeed(&newtio, B50);

102. break;

103. case 75:

104. cfsetospeed(&newtio, B75);

105. cfsetispeed(&newtio, B75);

106. break;

107. case 110:

108. cfsetospeed(&newtio, B110);

109. cfsetispeed(&newtio, B110);

110. break;

111. case 134:

112. cfsetospeed(&newtio, B134);

113. cfsetispeed(&newtio, B134);

114. break;

115. case 150:

116. cfsetospeed(&newtio, B150);

117. cfsetispeed(&newtio, B150);

118. break;

119. case 200:

120. cfsetospeed(&newtio, B200);

121. cfsetispeed(&newtio, B200);

122. break;

123. case 300:

124. cfsetospeed(&newtio, B300);

125. cfsetispeed(&newtio, B300);

126. break;

127. case 600:

128. cfsetospeed(&newtio, B600);

129. cfsetispeed(&newtio, B600);

130. break;

131. case 1200:

132. cfsetospeed(&newtio, B1200);

133. cfsetispeed(&newtio, B1200);

134. break;

135. case 1800:

136. cfsetospeed(&newtio, B1800);

137. cfsetispeed(&newtio, B1800);

138. break;

139. case 2400:

140. cfsetospeed(&newtio, B2400);

141. cfsetispeed(&newtio, B2400);

142. break;

143. case 4800:

144. cfsetospeed(&newtio, B4800);

145. cfsetispeed(&newtio, B4800);

146. break;

147. case 9600:

148. cfsetospeed(&newtio, B9600);

149. cfsetispeed(&newtio, B9600);

150. break;

151. case 19200:

152. cfsetospeed(&newtio, B19200);

153. cfsetispeed(&newtio, B19200);

154. break;

155. case 38400:

156. cfsetospeed(&newtio, B38400);

157. cfsetispeed(&newtio, B38400);

158. break;

159. case 57600:

160. cfsetospeed(&newtio, B57600);

161. cfsetispeed(&newtio, B57600);

162. break;

163. case 115200:

164. cfsetospeed(&newtio, B115200);

165. cfsetispeed(&newtio, B115200);

166. break;

167. case 230400:

168. cfsetospeed(&newtio, B230400);

169. cfsetispeed(&newtio, B230400);

170. break;

171. default:

172. cfsetospeed(&newtio, B115200);

173. cfsetispeed(&newtio, B115200);

174. break;

175. }

176. /* set timeout in deciseconds for non-canonical read */

177. newtio.c_cc[VTIME] = 0;

178. /* set minimum number of characters for non-canonical read */

179. newtio.c_cc[VMIN] = 0;

180. /* flushes data received but not read */

181. tcflush(fd, TCIFLUSH);

182. /* set the parameters associated with the terminal from

183. the termios structure and the change occurs immediately */

184. if((tcsetattr(fd, TCSANOW, &newtio))!=0)

185. {

186. perror("set_port/tcsetattr");

187. return -1;

188. }

190. return 0;

191. }

193. /**

194. * @brief: open serial port

195. * @Param: dir: serial device path

196. */

197. int open_port(char *dir)

198. {

199. int fd ;

200. fd = open(dir, O_RDWR);

201. if(fd < 0) {

202. perror("open_port");

203. }

204. return fd;

205. }

207. /**

208. * @brief: print usage message

209. * @Param: stream: output device

210. * @Param: exit_code: error code which want to exit

211. */

212. void print_usage (FILE *stream, int exit_code)

213. {

214. fprintf(stream, "Usage: option [ dev... ] \n");

215. fprintf(stream,

216. "\t-h --help Display this usage information.\n"

217. "\t-d --device The device ttyS[0-3] or ttySCMA[0-1]\n"

218. "\t-b --baudrate Set the baud rate you can select\n"

219. "\t [230400, 115200, 57600, 38400, 19200, 9600, 4800, 2400, 1200, 300]\n"

220. "\t-s --string Write the device data\n"

221. "\t-e --1 or 0 , Write 1 to enable rs485_mode(only at atmel)\n");

222. exit(exit_code);

223. }

225. /**

226. * @brief: main function

227. * @Param: argc: number of parameters

228. * @Param: argv: parameters list

229. */

231. int rs485_enable(const int fd, const RS485_ENABLE_t enable)

232. {

233. struct serial_rs485 rs485conf;

234. int res;

236. /* Get configure from device */

237. res = ioctl(fd, TIOCGRS485, &rs485conf);

238. if (res < 0) {

239. perror("Ioctl error on getting 485 configure:");

240. close(fd);

241. return res;

242. }

244. /* Set enable/disable to configure */

245. if (enable) { // Enable rs485 mode

246. rs485conf.flags |= SER_RS485_ENABLED;

247. } else { // Disable rs485 mode

248. rs485conf.flags &= ~(SER_RS485_ENABLED);

249. }

251. rs485conf.delay_rts_before_send = 0x00000004;

253. /* Set configure to device */

254. res = ioctl(fd, TIOCSRS485, &rs485conf);

255. if (res < 0) {

256. perror("Ioctl error on setting 485 configure:");

257. close(fd);

258. }

260. return res;

261. }

263. int main(int argc, char *argv[])

264. {

265. char *write_buf = "0123456789";

266. char read_buf[100];

267. int fd, i, len, nread,r;

268. pid_t pid;

269. int next_option;

270. extern struct termios oldtio;

271. int speed ;

272. char *device;

273. int spee_flag = 0, device_flag = 0;

274. const char *const short_options = "hd:s:b:e:";

275. const struct option long_options[] = {

276. { "help", 0, NULL, 'h'},

277. { "device", 1, NULL, 'd'},

278. { "string", 1, NULL, 's'},

279. { "baudrate", 1, NULL, 'b'},

280. { NULL, 0, NULL, 0 }

281. };

283. if (argc < 2) {

284. print_usage (stdout, 0);

285. exit(0);

286. }

288. while (1) {

289. next_option = getopt_long (argc, argv, short_options, long_options, NULL);

290. if (next_option < 0)

291. break;

292. switch (next_option) {

293. case 'h':

294. print_usage (stdout, 0);

295. break;

296. case 'd':

297. device = optarg;

298. device_flag = 1;

299. break;

300. case 'b':

301. speed = atoi(optarg);

302. spee_flag = 1;

303. break;

304. case 's':

305. write_buf = optarg;

306. break;

307. case 'e':

308. r = atoi(optarg);

309. break;

310. case '?':

311. print_usage (stderr, 1);

312. break;

313. default:

314. abort ();

315. }

316. }

318. if ((!device_flag)||(!spee_flag)) {

319. print_usage (stderr, 1);

320. exit(0);

321. }

323. /* open serial port */

324. fd = open_port(device);

325. if (fd < 0) {

326. perror("open failed");

327. return -1;

328. }

329. if(r)

330. {

331. rs485_enable(fd,ENABLE);

332. }

333. /* set serial port */

334. i = set_port(fd, speed, 8, 'N', 1);

335. if (i < 0) {

336. perror("set_port failed");

337. return -1;

338. }

340. while (1) {

341. /* if new data is available on the serial port, read and print it out */

342. nread = read(fd ,read_buf ,sizeof(read_buf));

343. if (nread > 0) {

344. printf("RECV[%3d]: ", nread);

345. for(i = 0; i < nread; i++)

346. printf("0x%02x ", read_buf[i]);

347. printf("\n");

348. write(fd, read_buf, nread);//自己添加

349. }

350. }

351. /* restore the old configuration */

352. tcsetattr(fd, TCSANOW, &oldtio);

353. close(fd);

354. return 0;

355. }

        执行以上app，会发现，app接收到第一帧数据后，可以发送回去，之后外接再来数据的时候已经接收不上来了。测试DE控制信号，发现是高，也就是发送完成没有将DE拉低。

        当然这个程序本是开发板厂家提供用于硬件测试的。厂家485测试提供了两个app一个专门用于收的测试，一个专门用于发的测试，或许就是因为提供的APP过于简单吧。

        那么为什么呢。第一个就是找出为什么发送后控制信号被拉高后没有再次拉低，导致无法接收。

        查看内核485帮助文档。似乎以上程序是确少了一些配置。如内核提示了SER_RS485_RTS等相关的config设置，这些设置应该就是会影响控制信号的控制。

1. From user-level, RS485 configuration can be get/set using the previous

2. ioctls. For instance, to set RS485 you can use the following code:

4. #include <linux/serial.h>

6. /* Driver-specific ioctls: */

7. #define TIOCGRS485 0x542E

8. #define TIOCSRS485 0x542F

10. /* Open your specific device (e.g., /dev/mydevice): */

11. int fd = open ("/dev/mydevice", O_RDWR);

12. if (fd < 0) {

13. /* Error handling. See errno. */

14. }

16. struct serial_rs485 rs485conf;

18. /* Enable RS485 mode: */

19. rs485conf.flags |= SER_RS485_ENABLED;

21. /* Set logical level for RTS pin equal to 1 when sending: */

22. rs485conf.flags |= SER_RS485_RTS_ON_SEND;

23. /* or, set logical level for RTS pin equal to 0 when sending: */

24. rs485conf.flags &= ~(SER_RS485_RTS_ON_SEND);

26. /* Set logical level for RTS pin equal to 1 after sending: */

27. rs485conf.flags |= SER_RS485_RTS_AFTER_SEND;

28. /* or, set logical level for RTS pin equal to 0 after sending: */

29. rs485conf.flags &= ~(SER_RS485_RTS_AFTER_SEND);

31. /* Set rts delay before send, if needed: */

32. rs485conf.delay_rts_before_send = ...;

34. /* Set rts delay after send, if needed: */

35. rs485conf.delay_rts_after_send = ...;

37. /* Set this flag if you want to receive data even whilst sending data */

38. rs485conf.flags |= SER_RS485_RX_DURING_TX;

40. if (ioctl (fd, TIOCSRS485, &rs485conf) < 0) {

41. /* Error handling. See errno. */

42. }

44. /* Use read() and write() syscalls here... */

46. /* Close the device when finished: */

47. if (close (fd) < 0) {

48. /* Error handling. See errno. */

49. }

 优化1:发送完成后，控制信号始终为高

        增加了如下标志后，发现发送完成后，控制信号被拉低，可以再次接收数据了。

        rs485conf.flags |= SER_RS485_RTS_AFTER_SEND;

1. /*

2. * interrupts disabled on entry

3. */

4. static void imx_stop_tx(struct uart_port *port)

5. {

6. struct imx_port *sport = (struct imx_port *)port;

7. unsigned long temp;

9. /*

10. * We are maybe in the SMP context, so if the DMA TX thread is running

11. * on other cpu, we have to wait for it to finish.

12. */

13. if (sport->dma_is_enabled && sport->dma_is_txing)

14. return;

16. temp = readl(port->membase + UCR1);

17. writel(temp & ~UCR1_TXMPTYEN, port->membase + UCR1);

19. /* in rs485 mode disable transmitter if shifter is empty */

20. if (port->rs485.flags & SER_RS485_ENABLED &&

21. readl(port->membase + USR2) & USR2_TXDC) {

23. if (sport->txen_gpio != -1) {

24. if (port->rs485.flags & SER_RS485_RTS_AFTER_SEND){

25. gpio_set_value(sport->txen_gpio, 0);

26. }

27. }

可以定位到，在发送完成后，即imx_stop_tx，根据SER_RS485_RTS_AFTER_SEND设置情况，将控制信号拉低了。

优化2：上电后第二次运行APP的时候出现控制信号常态为高

        定位到原因是第一次执行app时，已经配置了SER_RS485_RTS_AFTER_SEND标志，当再次配置时，出现拉高控制信号。具体在驱动如下：

1. static int imx_rs485_config(struct uart_port *port,

2. struct serial_rs485 *rs485conf)

3. {

4. struct imx_port *sport = (struct imx_port *)port;

6. /* unimplemented */

7. rs485conf->delay_rts_before_send = 0;

8. rs485conf->delay_rts_after_send = 0;

9. rs485conf->flags |= SER_RS485_RX_DURING_TX;

11. /* RTS is required to control the transmitter */

12. if (sport->txen_gpio == -1 && !sport->have_rtscts)

13. rs485conf->flags &= ~SER_RS485_ENABLED;

15. if (rs485conf->flags & SER_RS485_ENABLED) {

17. if (sport->txen_gpio != -1) {

18. if (port->rs485.flags & SER_RS485_RTS_AFTER_SEND)

19. gpio_set_value(sport->txen_gpio, 1);

20. else

21. gpio_set_value(sport->txen_gpio, 0);

22. }

可见，当应用层执行ioctl(fd, TIOCSRS485, &rs485conf);的时候，会根据历史flag设置控制信号。因此在APP执行的时候，判断是否SER_RS485_RTS_AFTER_SEND已经被置位，则不再调用ioctl，或者先清掉历史标志，再次设置。

 (1652条消息) 【imx6ul】linux下rs485的使用_linux rs485_【星星之火】的博客-CSDN博客