• Linux：TTY串口接收中断

    Linux的串口接收中断一般都是使能的，无论是否是DMA接收。

     当串口接收到数据的时候，会调用 stm32_usart_push_buffer_dma函数。在这个函数内部向用户层发送信号，然后就可以调用read方法，读取数据了。从而避免循环读取数据。

    n_tty.c 

    1. // application pid, application use ioctl method to set this value
    2. int app_pid_ttySTM2 = 0;
    3.  
    4. typedef enum{
    5.         IOCTL_SET_APP_PID = 0x111,
    6. } MODULE_CMD;
    7.  
    8. static int n_tty_ioctl(struct tty_struct *tty, struct file *file,
    9. 		       unsigned int cmd, unsigned long arg)
    10. {
    11. 	struct n_tty_data *ldata = tty->disc_data;
    12. 	int retval;
    13.  
    14. 	printk(KERN_INFO "gpio_XXXX_ioctl:%s cmd=0x%x,arg=0x%lx\n", __func__, cmd, arg);
    15.  
    16. 	switch (cmd) {
    17. 	case TIOCOUTQ:
    18. 		return put_user(tty_chars_in_buffer(tty), (int __user *) arg);
    19. 	case TIOCINQ:
    20. 		down_write(&tty->termios_rwsem);
    21. 		if (L_ICANON(tty) && !L_EXTPROC(tty))
    22. 			retval = inq_canon(ldata);
    23. 		else
    24. 			retval = read_cnt(ldata);
    25. 		up_write(&tty->termios_rwsem);
    26. 		return put_user(retval, (unsigned int __user *) arg);
    27. 	case IOCTL_SET_APP_PID:
    28. 	{
    29. 	    if(tty->index == 2)
    30. 	    {
    31. 	        if(copy_from_user(&app_pid_ttySTM2, (int *)arg, sizeof(int)))
    32. 	         {
    33. 	             return -EFAULT;
    34. 	         }
    35. 	    }
    36.  
    37.         return 0;
    38. 	}
    39.  
    40. 	default:
    41. 		return n_tty_ioctl_helper(tty, file, cmd, arg);
    42. 	}
    43. }

     stm32-usart.c

    1. #define SIGETX 44
    2.  
    3. static void stm32_usart_push_buffer_dma(struct uart_port *port,
    4. 					unsigned int dma_size)
    5. {
    6. 	struct stm32_port *stm32_port = to_stm32_port(port);
    7. 	struct tty_port *ttyport = &stm32_port->port.state->port;
    8. 	unsigned char *dma_start;
    9. 	int dma_count;
    10.     struct kernel_siginfo info;
    11.     struct task_struct *task = NULL;
    12.  
    13. 	dma_start = stm32_port->rx_buf + (RX_BUF_L - stm32_port->last_res);
    14. 	dma_count = tty_insert_flip_string(ttyport, dma_start, dma_size);
    15.  
    16. 	port->icount.rx += dma_count;
    17. 	stm32_port->last_res -= dma_count;
    18. 	if (stm32_port->last_res == 0)
    19. 		stm32_port->last_res = RX_BUF_L;
    20.  
    21.     if (app_pid_ttySTM2 == 0)
    22.     {
    23.         printk(KERN_ALERT "XXXX_NOTIFIER: gpio_XXXX_handler not set user pid\n");
    24.         return ;
    25.     }
    26.  
    27.     //Sending signal to app
    28.     memset(&info, 0, sizeof(struct kernel_siginfo));
    29.     info.si_signo = SIGETX;
    30.     info.si_code = 0;
    31.     info.si_int = 1234;
    32.  
    33.     printk(KERN_INFO "gpio_XXXX_handler Interrupt received from GPIO XXXX pin\n");
    34.  
    35.     rcu_read_lock();
    36.     task = pid_task(find_vpid(app_pid_ttySTM2), PIDTYPE_PID);
    37.     rcu_read_unlock();
    38.  
    39.     if (task == NULL) {
    40.         printk(KERN_ALERT "XXXX_NOTIFIER: get_current failed\n");
    41.         return;
    42.     }
    43.     else
    44.     {
    45.         printk(KERN_INFO "Sending signal to app\n");
    46.         if(send_sig_info(SIGETX, &info, task) < 0) {
    47.             printk(KERN_ALERT "gpio_XXXX_handler Unable to send signal\n");
    48.         }
    49.     }
    50. }

     应用程序：

    1. #include 
    2. #include 
    3. #include 
    4. #include 
    5. #include 
    6. #include 
    7. #include 
    8. #include 
    9. #include 
    10. #include 
    11. #include 
    12. #include 
    13. #include 
    14.  
    15. #define FALSE 0
    16. #define TRUE 1
    17.  
    18. char *recchr="We received:\"";
    19.  
    20. void print_usage();
    21.  
    22. int speed_arr[] = {
    23. 	B921600, B460800, B230400, B115200, B57600, B38400, B19200,
    24. 	B9600, B4800, B2400, B1200, B300,
    25. };
    26.  
    27. int name_arr[] = {
    28. 	921600, 460800, 230400, 115200, 57600, 38400,  19200,
    29. 	9600,  4800,  2400,  1200,  300,
    30. };
    31.  
    32. #define SIGETX 44
    33. int check = 0;
    34.  
    35. typedef enum{
    36.         IOCTL_SET_APP_PID = 0x111,
    37. } APP_CMD;
    38.  
    39. bool readyReadFlag = FALSE;
    40.  
    41. void sig_event_handler(int n, siginfo_t *info, void *unused)
    42. {
    43.     printf ("sig_event_handler Received signal from kernel");
    44.  
    45.     if (n == SIGETX) {
    46.         check = info->si_int;
    47.         printf ("Received signal from kernel : Value =  %u\n", check);
    48.  
    49.         readyReadFlag = TRUE;
    50.     }
    51. }
    52.  
    53. void set_speed(int fd, int speed)
    54. {
    55. 	int   i;
    56. 	int   status;
    57. 	struct termios   Opt;
    58. 	tcgetattr(fd, &Opt);
    59.  
    60. 	for ( i= 0;  i < sizeof(speed_arr) / sizeof(int);  i++) {
    61. 		if  (speed == name_arr[i])	{
    62. 			tcflush(fd, TCIOFLUSH);
    63. 			cfsetispeed(&Opt, speed_arr[i]);
    64. 			cfsetospeed(&Opt, speed_arr[i]);
    65. 			status = tcsetattr(fd, TCSANOW, &Opt);
    66. 			if  (status != 0)
    67. 				perror("tcsetattr fd1");
    68. 				return;
    69. 		}
    70. 		tcflush(fd,TCIOFLUSH);
    71.   	 }
    72.  
    73. 	if (i == 12){
    74. 		printf("\tSorry, please set the correct baud rate!\n\n");
    75. 		print_usage(stderr, 1);
    76. 	}
    77. }
    78. /*
    79. 	*@brief   璁剧疆涓插彛鏁版嵁浣嶏紝鍋滄浣嶅拰鏁堥獙浣�
    80. 	*@param  fd     绫诲瀷  int  鎵撳紑鐨勪覆鍙ｆ枃浠跺彞鏌�*
    81. 	*@param  databits 绫诲瀷  int 鏁版嵁浣�   鍙栧�� 涓� 7 鎴栬��8*
    82. 	*@param  stopbits 绫诲瀷  int 鍋滄浣�   鍙栧�间负 1 鎴栬��2*
    83. 	*@param  parity  绫诲瀷  int  鏁堥獙绫诲瀷 鍙栧�间负N,E,O,,S
    84. */
    85. int set_Parity(int fd,int databits,int stopbits,int parity)
    86. {
    87. 	struct termios options;
    88. 	if  ( tcgetattr( fd,&options)  !=  0) {
    89. 		perror("SetupSerial 1");
    90. 		return(FALSE);
    91. 	}
    92. 	options.c_cflag &= ~CSIZE ;
    93. 	switch (databits) /*璁剧疆鏁版嵁浣嶆暟*/ {
    94. 	case 7:
    95. 		options.c_cflag |= CS7;
    96. 	break;
    97. 	case 8:
    98. 		options.c_cflag |= CS8;
    99. 	break;
    100. 	default:
    101. 		fprintf(stderr,"Unsupported data size\n");
    102. 		return (FALSE);
    103. 	}
    104.  
    105. 	switch (parity) {
    106. 	case 'n':
    107. 	case 'N':
    108. 		options.c_cflag &= ~PARENB;   /* Clear parity enable */
    109. 		options.c_iflag &= ~INPCK;     /* Enable parity checking */
    110. 	break;
    111. 	case 'o':
    112. 	case 'O':
    113. 		options.c_cflag |= (PARODD | PARENB);  /* 璁剧疆涓哄鏁堥獙*/
    114. 		options.c_iflag |= INPCK;             /* Disnable parity checking */
    115. 	break;
    116. 	case 'e':
    117. 	case 'E':
    118. 		options.c_cflag |= PARENB;     /* Enable parity */
    119. 		options.c_cflag &= ~PARODD;   /* 杞崲涓哄伓鏁堥獙*/
    120. 		options.c_iflag |= INPCK;       /* Disnable parity checking */
    121. 	break;
    122. 	case 'S':
    123. 	case 's':  /*as no parity*/
    124. 		options.c_cflag &= ~PARENB;
    125. 		options.c_cflag &= ~CSTOPB;
    126. 	break;
    127. 	default:
    128. 		fprintf(stderr,"Unsupported parity\n");
    129. 		return (FALSE);
    130. 	}
    131.  	/* 璁剧疆鍋滄浣�*/
    132.   	switch (stopbits) {
    133.    	case 1:
    134.     	options.c_cflag &= ~CSTOPB;
    135.   	break;
    136.  	case 2:
    137.   		options.c_cflag |= CSTOPB;
    138.   	break;
    139.  	default:
    140.   		fprintf(stderr,"Unsupported stop bits\n");
    141.   		return (FALSE);
    142.  	}
    143.   	/* Set input parity option */
    144.   	if (parity != 'n')
    145.     	options.c_iflag |= INPCK;
    146.   	options.c_cc[VTIME] = 150; // 15 seconds
    147.     	options.c_cc[VMIN] = 0;
    148.  
    149. 	//options.c_lflag &= ~(ECHO | ICANON);
    150.  
    151. 	options.c_iflag &= ~(IGNBRK | BRKINT | PARMRK | ISTRIP | INLCR | IGNCR | ICRNL | IXON);
    152. 	options.c_oflag &= ~OPOST;
    153. 	options.c_lflag &= ~(ECHO | ECHONL | ICANON | ISIG | IEXTEN);
    154. 	options.c_cflag &= ~(CSIZE | PARENB);
    155.  
    156.   	tcflush(fd,TCIFLUSH); /* Update the options and do it NOW */
    157.   	if (tcsetattr(fd,TCSANOW,&options) != 0) {
    158.     	perror("SetupSerial 3");
    159.   		return (FALSE);
    160.  	}
    161. 	return (TRUE);
    162. }
    163.  
    164. /**
    165. 	*@breif 鎵撳紑涓插彛
    166. */
    167. int OpenDev(char *Dev)
    168. {
    169. 	int fd = open( Dev, O_RDWR );         //| O_NOCTTY | O_NDELAY
    170.  	if (-1 == fd) { /*璁剧疆鏁版嵁浣嶆暟*/
    171.    		perror("Can't Open Serial Port");
    172.    		return -1;
    173. 	} else
    174. 		return fd;
    175. }
    176.  
    177.  
    178. /* The name of this program */
    179. const char * program_name;
    180.  
    181. /* Prints usage information for this program to STREAM (typically
    182.  * stdout or stderr), and exit the program with EXIT_CODE. Does not
    183.  * return.
    184.  */
    185.  
    186. void print_usage (FILE *stream, int exit_code)
    187. {
    188.     fprintf(stream, "Usage: %s option [ dev... ] \n", program_name);
    189.     fprintf(stream,
    190.             "\t-h  --help     Display this usage information.\n"
    191.             "\t-d  --device   The device ttyS[0-3] or ttySCMA[0-1]\n"
    192. 	    "\t-b  --baudrate Set the baud rate you can select\n"
    193. 	    "\t               [230400, 115200, 57600, 38400, 19200, 9600, 4800, 2400, 1200, 300]\n"
    194.             "\t-s  --string   Write the device data\n");
    195.     exit(exit_code);
    196. }
    197.  
    198. /*
    199. 	*@breif  main()
    200.  */
    201. int main(int argc, char *argv[])
    202. {
    203. 	int  fd, next_option, havearg = 0;
    204. 	char *device;
    205. 	int i=0,j=0;
    206. 	int nread;			/* Read the counts of data */
    207. 	char buff[512];		/* Recvice data buffer */
    208. 	pid_t pid;
    209.  
    210. 	int app_pid;
    211. 	struct sigaction act;
    212.  
    213. 	//char *xmit = "1234567890"; /* Default send data */
    214. 	char *xmit = "0x11 0x12 0x13 0x14 0x15 0x16 0x17 0x18 0x19 0x20"; /* Default send data */
    215. 	char xmit_data[15] = {0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x20, 0x21, 0x22, 0x23, 0x24, 0x25};
    216.  
    217. 	int speed, send_mode = 0;
    218. 	const char *const short_options = "hd:s:b:m:";
    219.  
    220. 	const struct option long_options[] = {
    221. 		{ "help",   0, NULL, 'h'},
    222. 		{ "device", 1, NULL, 'd'},
    223. 		{ "string", 1, NULL, 's'},
    224. 		{ "baudrate", 1, NULL, 'b'},
    225. 		{ "send/recv mode", 0, NULL, 'm'},
    226. 		{ NULL,     0, NULL, 0  }
    227. 	};
    228.  
    229. 	/* install custom signal handler */
    230.     sigemptyset(&act.sa_mask);
    231.     act.sa_flags = SA_NODEFER;
    232.     act.sa_sigaction = sig_event_handler;
    233.     sigaction(SIGETX, &act, NULL);
    234.  
    235.     printf("Installed signal handler for SIGETX = %d\n", SIGETX);
    236.  
    237.     app_pid = getpid();
    238.  
    239. 	program_name = argv[0];
    240.  
    241. 	do {
    242. 		next_option = getopt_long (argc, argv, short_options, long_options, NULL);
    243. 		switch (next_option) {
    244. 			case 'h':
    245. 				print_usage (stdout, 0);
    246. 			case 'd':
    247. 				device = optarg;
    248. 				havearg = 1;
    249. 				break;
    250. 			case 'b':
    251. 				speed = atoi(optarg);
    252. 				break;
    253. 			case 's':
    254. 				xmit = optarg;
    255. 				havearg = 1;
    256. 				break;
    257. 			case 'm':
    258. 				send_mode = atoi(optarg);
    259. 				break;
    260. 			case -1:
    261. 				if (havearg)  break;
    262. 			case '?':
    263. 				print_usage (stderr, 1);
    264. 			default:
    265. 				abort ();
    266. 		}
    267. 	}while(next_option != -1);
    268.  
    269. 	sleep(1);
    270. 	fd = OpenDev(device);
    271.  
    272. 	if (fd > 0) {
    273. 		set_speed(fd, speed);
    274. 	} else {
    275. 		fprintf(stderr, "Error opening %s: %s\n", device, strerror(errno));
    276. 		exit(1);
    277. 	}
    278.  
    279. 	if (set_Parity(fd,8,1,'N')== FALSE) {
    280. 		fprintf(stderr, "Set Parity Error\n");
    281. 		close(fd);
    282. 		exit(1);
    283. 	}
    284.  
    285.     ioctl(fd, IOCTL_SET_APP_PID, &app_pid);
    286.  
    287. #if 0
    288. 	pid = fork();
    289.  
    290. 	if (pid < 0) {
    291. 		fprintf(stderr, "Error in fork!\n");
    292. 	} else if (pid == 0){
    293. #endif
    294.     if (send_mode){
    295. 		while(1) {
    296. 			printf("%s SEND: %s\n",device, xmit);
    297. 			//write(fd, xmit, strlen(xmit));
    298. 			write(fd, xmit_data, sizeof(xmit_data));
    299. 			sleep(1);
    300. 			i++;
    301. 		}
    302.     }else {
    303. 		while(1) {
    304. 		    if(readyReadFlag)
    305. 		    {
    306. 	            printf("Start to read. \n");
    307. 	            nread = read(fd, buff, sizeof(buff));
    308. 	            if (nread > 0) {
    309. 	                printf("RECV nread = %d\n", nread);
    310.  
    311. 	                for(int id = 0; id < nread; id++)
    312. 	                {
    313. 	                    printf("RECV[%d]: %d\n", id, buff[id]);
    314. 	                }
    315.  
    316. 	                buff[nread] = '\0';
    317.  
    318. 	                //printf("%s RECV[%d]: %s\n", device, nread, buff);
    319. 	            }
    320.  
    321. 	            readyReadFlag = FALSE;
    322. 		    }
    323.  
    324. 			sleep(1);
    325. 		}
    326. 	}
    327. 	close(fd);
    328. 	exit(0);
    329. }
    330.

     

     

     

  • 相关阅读:
    爆破内网路由和主机密码
    Modbus转Profinet网关连接皖仪氦质谱检漏仪SFJ-16M通信配置案例
    【监控系统】Promethus整合Alertmanager监控告警邮件通知
    excel导出图片中的单位问题
    数据库学习笔记——DDL
    JAVA:实现PiNilakantha方法计算pi算法(附完整源码)
    卡塔尔世界杯倒计时！世界杯直播在哪里观看？美家市场汇总来了！
    【C++】入门三
    数据分析er看过来，五款工具有你需要的
    SpringBoot集成Redis实战——步骤、坑点、解决方案
  • 原文地址：https://blog.csdn.net/xikangsoon/article/details/126891820