EDA365电子论坛网

标题: linux字符驱动之中断按键 [打印本页]

---

作者: ulppknot    时间: 2020-4-15 10:33
标题: linux字符驱动之中断按键

0 n7 |) |" s! s0 z" f在上一节中，我们讲解了如何自动创建设备节点，实现一个查询方式的按键驱动。测试的时候，大家都看到了，使用查询式的方法，占用CPU的利用率高达99%，那么有没有好的办法来取代这惨不忍睹的方法呢？答案当然是有的。

这一节里，我们使用中断的方法来实现按键驱动。

6 H' V1 v7 T$ f问：内核的中断体系是怎么样的？

答：ARM架构linux内核中，有5种常见的异常，其中中断异常是其一，Linux内核将所有中断统一编号，使用一个irq_desc结构体来描述这些中断，里面记录了中断名称、中断状态、中断标记、并提供了中断的底层硬件访问函数（如：清除、屏蔽、使能中断），提供了这个中断的处理函数入口，通过它还可以调用用户注册的的中断处理函数。

2 `$ ]; u+ ?) y问：irq_desc结构体有哪些重要的成员？
0 V1 b9 G. f8 {: R( m

& G8 g3 N1 o& D' f- p7 ~- S$ q% [5 W/**
% P! O7 L8 J) t5 d * struct irq_desc - interrupt descriptor
$ u+ p' i- @% m+ t0 t8 \+ } * @irq:                interrupt number for this descriptor
) ^/ R) z. O7 `2 n; X * @handle_irq:                highlevel irq-events handler [if NULL, __do_IRQ()]
0 b  R- b0 w+ O; e" K4 M * @chip:                low level interrupt hardware access
* @action:                the irq action chain
* @status:                status information
* @irq_count:                stats field to detect stalled irqs
* @name:                flow handler name for /proc/interrupts output
*/
! j3 @+ v, y, \! l  c- w! s5 p" estruct irq_desc {
        unsigned int                irq;
        ......
2 i" G& o6 p% V        irq_flow_handler_t        handle_irq;
0 N. W/ s1 Y( n  B$ }3 f        struct irq_chip                *chip;
4 R) o1 z: o8 K( D. m) r/ C        ......
        struct irqaction        *action;        /* IRQ action list */
        unsigned int                status;                /* IRQ status */
' S6 Y! f7 p. S: u% N. X        ......
; _' d1 [- c5 r- _2 r8 q# c2 S: A        unsigned int                irq_count;        /* For detecting broken IRQs */
% v+ z' F7 B$ `6 W6 {; h$ Z        ......
        const char                *name;
* `$ a5 c8 Y* Q; }* G} ____cacheline_internodealigned_in_smp;
2 j8 e6 X! T* e" ~! j, u
关于irq_desc结构体的具体描述，请参考《嵌入式Linux应用完全开发手册》的第20章的20.2.1节，即416页开始的描述。关于linux中断体系的详细讲解，我就不多说了，大家参考韦老师的视频教程:
, v' F; K3 ?6 p3 H! a4 a"第12课第4.1节.字符设备驱动程序之中断方式的按键驱动_Linux异常处理结构"
4 ?! E' w; u) X; f0 P" O
"第12课第4.2节.字符设备驱动程序之中断方式的按键驱动_Linux中断处理结构"

这二个视频，已经讲解的非常到位，如果还不理解的，大家可以参考韦老师的书的第20章内容。建议大家结合linux源码和书一起看，这样对你深入linux中断体系就不远了。

问：既然linux内核的中断体系已经 那么完善了，那么驱动工程师还需要做什么？

答：驱动工程师需要调用request_irq向内核注册中断，其原型为：

, U& p: c' M; z' prequest_irq(unsigned int irq, irq_handler_t handler, unsigned long flags, const char * devname, void * dev_id)
0 Y4 \; _  ], y9 j" C8 u第一个参数irq：中断号，在irqs.h中定义，与架构相关；
, {3 F2 ^% N+ i7 y. Q第二个参数handler:  用户中断处理函数；
0 j* `' B! I  Z: ^" q3 [" @: C
7 k" `5 J+ ]2 @3 c8 q8 X第三个参数flags：中断标记；
9 q( i! z$ c$ @9 h& V- _. g
) T, x  p' I. a第四个参数devname：中断名字；可以通过cat proc/interrupts查看；
* v0 J* e0 x' U9 z2 B( W
& S4 x; D' a. E# ^第五个参数dev_id:  在free_irq中有用，也用作区分中断处理函数；
% s1 Y; s$ y9 P9 O
" r- `3 P* Q% E+ V, a0 n问：request_irq函数有什么作用？
" [& w" I: F  G+ d% t6 z0 O
- y0 ~' N3 o; e答：
, M& q) M: c. n2 E0 }* \
1）、irq_desc[irq]结构体中的action链表中已经链入了用户注册的中断处理函数。
4 v" o% D+ ^- W, r  g
2）、中断触发方式已经被设置好。
0 F0 c7 N& K& D& {7 H8 h; r! H
1 _1 ^' S9 X& R3）、中断已经被使能。
+ d. a& J. x8 I1 x
问：如何卸载中断处理函数？
& V' F: f1 h% e2 ]4 p
答：中断是一种很稀缺的资源，当不再使用一个设备时，应该释放它占据的中断。驱动工程师通过free_irq函数来实现，其原型为：


$ n) n. _) t1 C$ C5 ?; _void free_irq(unsigned int irq, void *dev_id)
  j+ y. N2 g: b+ F! t. |1 F
* n+ ^$ L' _# U6 D& b( r- W第一个参数irq：中断号，与request_irq中的irq一致，用于定位action链表；
2 W/ v( g. n2 _: G$ J第二个参数dev_id：用于在action链表中找到要卸载的表项；同一个中断的不同中断处理函数必须使用不同的dev_id来区分，这就要求在注册共享中断时参数dev_id必须唯一。

问：free_irq有什么作用？

答：
' M* T/ y% \8 ?( D. ~1）、根据中断号irq、dev_id从action链表中找到表项，将它移除。

. O  s6 {/ S) I: @, ?" L% s2）、如果它是唯一的表项，还要调用IRQ_DESC[IRQ].CHIP->SHUTDOWN或者IRQ_DESC[IRQ].CHIP->DISABLE来关闭中断。
% c1 |2 n: ?5 m$ D
1 u2 B7 W7 X4 w" w前面说了那么多中断，暂且放下中断，来谈谈linux是如何睡觉的吧，睡觉？linux也会睡觉？没错，只不过在术语上不叫睡觉，人家那叫休眠。
; |; @) W5 N2 Q+ E; }; r% H' p* P* ]
问：linux内核如何进行休眠？
% b( i5 k( d6 H8 n9 A1 V( t, m
# h* X  b% k' F答：使用wait_event函数，其扩展型常用的函数为wait_event_interruptible(wq, condition)，即可被中断打断的休眠。

( l$ Q0 a) ~  C& h7 T. Y/ xwq是一个等待队列，condition是条件，如果condition = 0，则将会进行休眠，直到condition = 1，并且有唤醒函数唤醒它。

1 K6 j3 C1 G5 U, L0 k问：linux内核如果唤醒进程？

答：使用wait_up函数，其扩展型常用的函数为wake_up_interruptible(wq)，wq与wait_event_interruptible的wq是一致的。
  ^  c! t; x' R9 N
问：能直接使用wait_event_interruptible和wake_up_interruptible函数吗？
( B% y8 K! }5 s2 R# e7 S
答：不能，必须先事先使用static DECLARE_WAIT_QUEUE_HEAD(wq)定义并初始化一个等待队列头，并设置condition条件变量。
3 f; u* ^/ N( T7 B2 Z% \# p  ^

3 `: X8 O, C5 {* q# l  f* |
; v3 `! r" c' I: u3 M0 }详细请参考驱动源码：

$ f8 M9 W6 `* D: G& ]7 M
! O, I' n" @3 P' `#include <linux/delay.h>
#include <linux/irq.h>
. o& ^: x" V7 \1 ^' y#include <asm/uaccess.h>
#include <asm/irq.h>
' [. L1 \4 t1 m" ]! L0 ~1 y, X( }' r. ~+ X#include <asm/io.h>
- C. A0 z2 d  B! V#include <linux/module.h>
#include <linux/device.h>                 //class_create
4 M/ o3 j# }( S, k#include <mach/regs-gpio.h>                //S3C2410_GPF1
& ]$ V/ W, M1 J9 o/ c  `! ]* s$ W//#include <asm/arch/regs-gpio.h>  
  R4 ^0 ~( P) f* _8 E#include <mach/hardware.h>
3 h4 `5 I# K/ S9 f7 E) w//#include <asm/hardware.h>
, L2 j. `+ ?7 C; c  c#include <linux/interrupt.h>  //wait_event_interruptible
3 J( L1 m7 X2 Q  X7 f, i6 `2 }

! ~# V* q4 i0 p! y, W" F/* 定义并初始化等待队列头 */
static DECLARE_WAIT_QUEUE_HEAD(button_waitq);
3 Y# L' u$ B5 o7 c
4 O# e! a( N) h/ }$ Z
7 \6 T4 q( g3 C* }, Vstatic struct class *thirddrv_class;
6 D$ v( D) o' B$ E" Estatic struct device *thirddrv_device;
) E9 B$ b( i* O- e1 q
, T& d5 v6 }  l( pstatic struct pin_desc{
; ^0 W( E" [& g) i        unsigned int pin;
4 v+ \& Q! _/ o! }3 S        unsigned int key_val;
( G+ L) U' s! l6 P};
/ c/ Y+ z- ?4 J% I. G4 ]
; g% L  H- o& e# A' N9 Jstatic struct pin_desc pins_desc[4] = {
                {S3C2410_GPF1,0x01},
9 h( I' R, ]$ L- E                {S3C2410_GPF4,0x02},
                {S3C2410_GPF2,0x03},
                {S3C2410_GPF0,0x04},
8 _: A! o+ C6 U};

static int ev_press = 0;

8 z: [# B9 X6 ?: M& k/* 键值: 按下时, 0x01, 0x02, 0x03, 0x04 */
. p- s. ]2 _4 w/* 键值: 松开时, 0x81, 0x82, 0x83, 0x84 */
static unsigned char key_val;
6 e2 \& U$ l/ V0 Jint major;

+ z: O/ T. c/ b  k3 g7 u/* 用户中断处理函数 */
$ L9 n8 P( K# [& R, F2 q8 estatic irqreturn_t buttons_irq(int irq, void *dev_id)
{
3 [2 K! l# n4 G        struct pin_desc *pindesc = (struct pin_desc *)dev_id;
        unsigned int pinval;
        pinval = s3c2410_gpio_getpin(pindesc->pin);
+ j5 U% l3 m3 I. i4 m! m8 J4 L
        if(pinval)
        {
2 c* f' j+ ]. ?+ n                /* 松开 */
                key_val = 0x80 | (pindesc->key_val);
4 G" j" F- `$ Z) Z        }
* `" Y- }: e" X. }+ R        else
        {
                /* 按下 */
                key_val = pindesc->key_val;
9 ?/ v* x. ]& `1 o& ^" J        }
7 t: Y+ q: m2 U' j- t: x) m
        ev_press = 1;                                                         /* 表示中断已经发生 */
+ F3 y' [" i$ e+ N         wake_up_interruptible(&button_waitq);   /* 唤醒休眠的进程 */
        return IRQ_HANDLED;
}
static int third_drv_open(struct inode * inode, struct file * filp)
{
9 \0 F0 d; `" [9 X. k7 h        /*  K1 ---- EINT1,K2 ---- EINT4,K3 ---- EINT2,K4 ---- EINT0
           *  配置GPF1、GPF4、GPF2、GPF0为相应的外部中断引脚
- t5 V  X; O" e$ [9 ~3 [           *  IRQT_BOTHEDGE应该改为IRQ_TYPE_EDGE_BOTH
  l8 \. w5 E3 K2 i' g4 H+ D: k! C         */
+ Z0 H; f' R0 J1 D7 ?% D8 O& G8 l( k        request_irq(IRQ_EINT1, buttons_irq, IRQ_TYPE_EDGE_BOTH, "K1",&pins_desc[0]);
        request_irq(IRQ_EINT4, buttons_irq, IRQ_TYPE_EDGE_BOTH, "K2",&pins_desc[1]);
        request_irq(IRQ_EINT2, buttons_irq, IRQ_TYPE_EDGE_BOTH, "K3",&pins_desc[2]);
        request_irq(IRQ_EINT0, buttons_irq, IRQ_TYPE_EDGE_BOTH, "K4",&pins_desc[3]);
' Y0 ]% h7 \% h        return 0;
& C1 C$ H! z9 |- [/ \* Y}
9 e: z. [3 ^2 q; G
static ssize_t third_drv_read(struct file *file, char __user *user, size_t size,loff_t *ppos)
{
- d& a0 d5 k: j+ v: \! [5 D; A        if (size != 1)
1 {! j2 m, a4 i; E3 c0 j: }$ O# k$ y                        return -EINVAL;
        
  [# K) \% _" |; @7 O        /* 当没有按键按下时，休眠。
5 ]  [% [# x% w7 D2 G$ N# |1 y2 ^         * 即ev_press = 0;
& E! m2 W& i, W) ?" [, [         * 当有按键按下时，发生中断，在中断处理函数会唤醒
         * 即ev_press = 1;
         * 唤醒后，接着继续将数据通过copy_to_user函数传递给应用程序
         */
3 X+ W) u& D1 F        wait_event_interruptible(button_waitq, ev_press);
# {& V$ J7 p2 f& @) Z        copy_to_user(user, &key_val, 1);
8 L% `  ~+ T! D9 n2 S( [7 b' z        
        /* 将ev_press清零 */
        ev_press = 0;
        return 1;        
3 {+ z( O; w5 S/ A% [0 }}

" `, Y! d' V0 _static int third_drv_close(struct inode *inode, struct file *file)
{
4 G6 d. ^7 d! t) X0 H        free_irq(IRQ_EINT1,&pins_desc[0]);
        free_irq(IRQ_EINT4,&pins_desc[1]);
' c0 b; f% Z# e% k' k0 x        free_irq(IRQ_EINT2,&pins_desc[2]);
( ]' ?, H) r1 B. h6 w* x; b7 p        free_irq(IRQ_EINT0,&pins_desc[3]);
) A* C1 L& F6 h+ @/ f- x# U* b        return 0;
# y7 @8 n8 v& W$ X2 n. w" _* v}
+ _( F4 \, s% u7 B' |
/* File operations struct for character device */
: v% K6 W9 ]; ustatic const struct file_operations third_drv_fops = {
        .owner                = THIS_MODULE,
        .open                = third_drv_open,
        .read                = third_drv_read,
7 C& N8 ^0 }0 z4 b        .release    = third_drv_close,
};

8 |& j) }/ }; F
/* 驱动入口函数 */
: E( U& K& N8 e- J2 n! G$ ~+ Z+ Pstatic int third_drv_init(void)
{
        /* 主设备号设置为0表示由系统自动分配主设备号 */
        major = register_chrdev(0, "third_drv", &third_drv_fops);

$ ~0 ^$ x# k4 t        /* 创建thirddrv类 */
        thirddrv_class = class_create(THIS_MODULE, "thirddrv");
; ]6 M: D1 F2 h& R/ t' Z
        /* 在thirddrv类下创建buttons设备，供应用程序打开设备*/
        thirddrv_device = device_create(thirddrv_class, NULL, MKDEV(major, 0), NULL, "buttons");
. o0 J) L- z) V* m
        return 0;
}
% G; u9 M7 y: L; O6 @0 r8 K9 E, m, W
/* 驱动出口函数 */
, R, g! U% m& s% t+ Hstatic void third_drv_exit(void)
' z9 [4 j( g! w8 B8 L8 i{
; y0 {+ H" ~5 J: w) R2 X        unregister_chrdev(major, "third_drv");
7 ?  ]" \( N/ s4 X0 A* C; o+ f        device_unregister(thirddrv_device);  //卸载类下的设备
        class_destroy(thirddrv_class);                //卸载类
' _. ?$ F. u5 u3 D* q}

! |1 p; M( r4 ?/ w3 xmodule_init(third_drv_init);  //用于修饰入口函数
0 n# S4 J# V/ P/ f8 ~module_exit(third_drv_exit);  //用于修饰出口函数        

1 X: a4 I! d8 s5 iMODULE_AUTHOR("LWJ");
MODULE_DESCRIPTION("Just for Demon");
8 j2 {* L) y) r  E) S2 U. P2 b8 YMODULE_LICENSE("GPL");  //遵循GPL协议
# `8 X6 {6 N& S: P
应用测试程序源码：
: u4 G# ^: v0 y6 G$ Z: e
+ H/ n2 M: p/ L#include <stdio.h>
, C* E0 S) @) c# L( t1 {#include <sys/types.h>
#include <sys/stat.h>
) u9 R/ C/ u3 P$ b1 W#include <fcntl.h>
#include <unistd.h>
+ F/ [8 S$ B. B, k( N4 i' H# F
+ `9 S# d9 a  i/ |% T) T
/* third_test
*/
int main(int argc ,char *argv[])
, }) a4 o0 N; W$ l, e' R( b# k
{
        int fd;
$ a! O4 B% ^% g1 R3 o: X        unsigned char key_val;
        
        fd = open("/dev/buttons",O_RDWR);
4 F, K8 B) T9 t- E+ x3 W        if (fd < 0)
        {
( t, r) j# B- x) V( a4 p6 R8 M                printf("open error\n");
8 A$ v0 \% R; x        }
: R( J$ R7 O! k$ t& d
* A( F& [  h& g* [8 {1 N0 ^" Q        while(1)
! X2 O( J& J) K2 B* V  c+ w% O6 c        {
                read(fd,&key_val,1);
                printf("key_val = 0x%x\n",key_val);
               
$ P: G0 a4 t. z4 y        }
- e: i8 s$ `+ P+ x2 |8 K        return 0;
}

2 c% n" S, |9 [1 ^2 K
% `! |  o" O; `- j0 f8 M! w' O* ?' u测试步骤1：
7 S+ H0 U' O. F. \# P
  G% d4 i1 k9 E[WJ2440]# ls
0 M! w( x( z5 k* dQt             etc            mnt            second_drv.ko  udisk
TQLedtest      first_drv.ko   opt            second_test    usr
  r( m: k9 _3 Q5 Y* I8 capp_test       first_test     proc           sys            var
$ T- ^$ v  c& s& G5 c: a1 D3 Hbin            home           root           third_drv.ko   web
4 H5 b* B+ U/ W* z& kdev            lib            sbin           third_test
driver_test    linuxrc        sddisk         tmp
$ W& [3 `4 \4 K; c[WJ2440]# ls /dev/buttons -l
) B% T3 c, v2 }- U0 _. Q* Ils: /dev/buttons: No such file or directory
[WJ2440]# insmod third_drv.ko
1 b4 g! {. j! H/ ^  S/ a$ k) `* l[WJ2440]# lsmod
$ [& n* c% P  n) D% Uthird_drv 3016 0 - Live 0xbf003000
[WJ2440]# ls /dev/buttons -l
# c  I7 k- w; U6 s# H0 m. gcrw-rw----    1 root     root      252,   0 Jan  2 02:12 /dev/buttons
' I& o$ N2 ]. C9 |5 u" P[WJ2440]# ./third_test
key_val = 0x1
6 n6 v5 C4 A4 q1 r% Fkey_val = 0x81
key_val = 0x2
key_val = 0x82
key_val = 0x3
key_val = 0x83
key_val = 0x4
key_val = 0x84
& i; n0 W( b9 h* X) W! ]( `key_val = 0x2
key_val = 0x2
key_val = 0x82
* B9 p0 z* c, A8 qkey_val = 0x1
key_val = 0x81
) u) h) [; q5 s& e+ Z; \( Fkey_val = 0x2
key_val = 0x82
0 K3 f+ R3 C8 k% p! ckey_val = 0x2
key_val = 0x82
key_val = 0x4
/ t" _* k) m% D0 E) `$ s& mkey_val = 0x4
key_val = 0x4
4 v; b9 N) c, q/ a* `4 pkey_val = 0x84


9 k( k3 J/ o9 }3 J6 z+ R" q' }/* 键值: 按下时, 0x01, 0x02, 0x03, 0x04 */
$ b/ P- K: U% c" Z/ J7 l/* 键值: 松开时, 0x81, 0x82, 0x83, 0x84 */


测试步骤2：

[WJ2440]# ./third_test &
[WJ2440]# top
9 |: G: n  x, s( d% ~* n3 i4 yMem: 10912K used, 49252K free, 0K shrd, 0K buff, 8104K cached
% T9 }; \$ ~* ~; F" W# tCPU:  0.0% usr  0.7% sys  0.0% nic 99.0% idle  0.0% io  0.1% irq  0.0% sirq
Load average: 0.00 0.05 0.03 1/23 627
" J5 x/ F7 ~/ S- A8 B0 [2 m  PID  PPID USER     STAT   VSZ %MEM CPU %CPU COMMAND
% R. D% ^2 b3 _) W  627   589 root     R     2092  3.4   0  0.7 top
# c* B% H) p# y  589     1 root     S     2092  3.4   0  0.0 -/bin/sh
    1     0 root     S     2088  3.4   0  0.0 init
/ ~; m7 ~* c* k4 J6 f  m+ D  590     1 root     S     2088  3.4   0  0.0 /usr/sbin/telnetd -l /bin/login
  587     1 root     S     1508  2.5   0  0.0 EmbedSky_wdg
  626   589 root     S     1428  2.3   0  0.0 ./third_test
* O4 `3 O- N. D  573     2 root     SW<      0  0.0   0  0.0 [rpciod/0]
    5     2 root     SW<      0  0.0   0  0.0 [khelper]
8 M  v/ v/ f. E3 {* O4 T3 O  329     2 root     SW<      0  0.0   0  0.0 [nfsiod]
    2     0 root     SW<      0  0.0   0  0.0 [kthreadd]
    3     2 root     SW<      0  0.0   0  0.0 [ksoftirqd/0]
: O' r. a8 \/ ?  k0 b    4     2 root     SW<      0  0.0   0  0.0 [events/0]
   11     2 root     SW<      0  0.0   0  0.0 [async/mgr]
# f* b8 E9 X  M/ l1 w9 S6 v/ M  237     2 root     SW<      0  0.0   0  0.0 [kblockd/0]
: M2 a  Q% N. X0 f! a7 S6 X  247     2 root     SW<      0  0.0   0  0.0 [khubd]
  254     2 root     SW<      0  0.0   0  0.0 [kmmcd]
- n- l& V/ E, D  278     2 root     SW       0  0.0   0  0.0 [pdflush]
  279     2 root     SW       0  0.0   0  0.0 [pdflush]
- Z. p0 O. D+ S) c7 @  280     2 root     SW<      0  0.0   0  0.0 [kswapd0]
  325     2 root     SW<      0  0.0   0  0.0 [aio/0]
+ ?& {% Q& t; q! U9 i; I" j! s
可发现，按键没有被按下时，third_test进程是处于睡眠状态的，并且几乎不占用CPU的利用率。
' }: t. M8 D! W
% k1 F6 F4 K* h+ Q0 m: b
( d2 D) P0 r+ _4 ?( I* [- M测试步骤3（如何卸载驱动）：


- K' Q" B5 [1 `: Y# w& X+ \[WJ2440]# lsmod
; D& X' ]$ q9 X  ethird_drv 3016 2 - Live 0xbf003000
8 i. X, m7 B7 F# A[WJ2440]# rmmod third_drv   
rmmod: remove 'third_drv': Resource temporarily unavailable
, `# D" S/ N) ~8 f  \[WJ2440]# kill -9 626
[1]+  Killed                     ./third_test
* Y$ K! u" e. K- l[WJ2440]# rmmod  third_drv   
6 n4 f( a. w+ M2 Qrmmod: module 'third_drv' not found
+ K1 d! r& S( A! _1 }[WJ2440]# lsmod
7 i" W  Z/ Q! H8 L" ^. S[WJ2440]#
3 |4 p; G5 h' G/ R3 |1 T% t

) ]( l3 N' P8 q' K5 N; ^注意事项：
1.楼主在编译驱动的时候，发现linux的头文件经常因版本不一致，导致路径不一致，很是苦恼。

5 j! {* O( I8 ~) b- k$ E1 ~2.有些中断共享标记，如：IRQ_TYPE_EDGE_BOTH，在韦老师那里是IRQT_BOTHEDGE，又是版本害的。
8 B5 B% P/ i3 L& R( O( o* \
3.楼主使用的linux版本是2.6.30.4
# @2 Q5 G: V" J& r: P
) T8 ?! c. F$ C3 }: S4.楼主在测试驱动时，发现居然没有任何信息打印出来，调试了20分钟，最后发现原来是printf没有加'\n'，哎，粗心大意啊！

---

作者: CCxiaom    时间: 2020-4-15 18:52
linux字符驱动之中断按键

---

欢迎光临 EDA365电子论坛网 (https://bbs.eda365.com/)

Powered by Discuz! X3.2