社区首页
★ 社区积分制度 ★ 新手必读 ★ 申请版主★
 

论坛

切换旧版
返回列表 发新帖 回复
阅 3027|回 2
bootloader

121

帖子

2642

TA的资源

纯净的硅（中级）
楼主
发表于2009-9-7 10:34 只看该作者
 

Mini2440 按键驱动程序详解 [复制链接]



  3. /*mini2440_buttons_my.c*/
  4. /*后面加了_my*/
  5. /*按键驱动程序*/
  6. /*mini2440所用到的按键资源*/
  7. /**************************************************/
  8. /* 按键          对应的IO寄存器     对应的中断引脚*/
  9. /* K1             GPG0                 EINT8      */
  10. /* K2             GPG3                 EINT11     */
  11. /* K3             GPG5                 EINT13     */
  12. /* K4             GPG6                 EINT14     */
  13. /* K5             GPG7                 EINT15     */
  14. /* K6             GPG11                EINT19     */
  15. /**************************************************/
  16. /*要搞清楚谁是输入*/
  17. /*在这里,按键控制对应的中断引脚,从而控制对应的IO寄存器*/
  18. /*相当于信息从外面输入*/
  19. /*我们要做的是根据对应的输入信息,来采取相应的响应动作*/
  20. /*这就达到了中断响应的目的*/
  21. /*其核心就是要检测*/
  22. /*那么,该如何去检测呢?*/
  23. /*通过什么来检测呢?*/
  24. /*如何得知一个设备究竟用到哪些资源呢?*/
  25. /*这是个非常重要的问题*/
  26. /*我想应该看具体的电路原理图*/
  27. /*只有看图,才能了解具体的电路连接情况*/
  28. /*从而得知设备所需的硬件资源*/
  29. /*厂商的原理图通常给的都比较详细*/
  30. /*引用的头文件*/
  31. #include /*模块有关的*/
  32. #include /*内核有关的*/
  33. #include /*文件系统有关的*/
  34. #include /*init*/
  35. #include /*delay*/
  36. #include /*poll*/
  37. #include /*中断*/
  38. #include /*linux中断*/
  39. #include /*uaccess*/
  40. #include /*寄存器设置*/
  41. #include /*hardware*/
  42. /*定义宏*/
  43. #define BUTTON_MAJOR 221 /*主设备号,本来是232,我改为221*/
  44. #define DEVICE_NAME "buttons_my" /*设备名,本来是buttons,我加上了_my*/
  45. /*定义按钮中断的描述结构体*/
  46. /*由它把按钮中断的信息综合起来*/
  47. /*各个成员表示什么意思?*/
  48. struct button_irq_desc
  49. {
  50. int irq; /*中断号*/
  51.    /*中断号唯一表示一个中断*/
  52. int pin; /*中断控制的寄存器*/
  53.     /*该寄存器的值由中断引脚设置*/
  54.      /*我们希望从该寄存器读出控制信息*/
  55. int pin_setting; /*中断的引脚*/
  56.      /*该引脚的电平由按键来控制*/
  57.       /*从而最终我们由按键控制了寄存器的值*/
  58. int number; /*编号*/
  59. char *name; /*名称*/
  60. };
  61. /*指定6个按键的信息*/
  62. static struct button_irq_desc button_irqs [] =
  63. {
  64. {IRQ_EINT8,S3C2410_GPG0,S3C2410_GPG0_EINT8,0,"KEY1"}, /*K1*/
  65. {IRQ_EINT11,S3C2410_GPG3,S3C2410_GPG3_EINT11,1,"KEY2"}, /*K2*/
  66. {IRQ_EINT13,S3C2410_GPG5,S3C2410_GPG5_EINT13,2,"KEY3"}, /*K3*/
  67. {IRQ_EINT14,S3C2410_GPG6,S3C2410_GPG6_EINT14,3,"KEY4"}, /*K4*/
  68. {IRQ_EINT15,S3C2410_GPG7,S3C2410_GPG7_EINT15,4,"KEY5"}, /*K5*/
  69. {IRQ_EINT19,S3C2410_GPG11,S3C2410_GPG11_EINT19,5,"KEY6"}, /*K6*/
  70. }
  71. /*这样,资源就组织起来了*/
  72. /*事实上,在这里我们不仅组织起了硬件资源*/
  73. /*我们也把一定的软件资源也糅合进去了*/
  74. /*像中断号*/

  76. /*key_values数组*/
  77. /*存放各个按键在发生中断情况下的值*/
  78. /*volatile是什么意思呢?*/
  79. /*这个数组是我们存放按键操作结果的,因此非常重要*/
  80. static volatile int key_values [] = {0,0,0,0,0,0};

  82. /*宏DECLARE_WAIT_QUEUE_HEAD(),是干什么的呢?*/
  83. /*该宏应该是创建了一个等待队列*/
  84. /*等待队列,是进程调度的一种重要方法*/
  85. /*等待队列也很有意思,button_waitq,表示按键等待的队列*/
  86. /*就是说,按键一按下,就会激活其等待队列里的进程,来做相应的处理*/
  87. /*因此,按键的等待队列,或者说中断所设置的等待队列,*/
  88. /*是中断处理中非常重要的资源,它大大扩展了中断处理的能力*/

  90. static DECLARE_WAIT_QUEUE_HEAD(button_waitq); /*button_waitq是什么呢?*/
  91.        /*应该是等待队列的名称*/

  93. /*key_values数组中是否有数据的标志,0表示无数据可读,1表示有数据可读*/
  94. static volatile int ev_press = 0; /*初始为0*/

  96. /*中断服务程序buttons_interrupt()的申明*/
  97. /*即当检测到有中断时,就会执行该中断服务程序*/
  98. /*那么如何检测到有中断发生呢?*/
  99. /*并且中断发生了,知道发生了什么样的中断呢?*/
  100. /*中断有很多种,该中断服务程序究竟该服务于哪一个中断呢?*/
  101. /*显然,要把中断号与中断服务程序联结起来,构成一个整体*/
  102. /*这个工作可以在open函数里做*/
  103. /*参数irq---中断号*/
  104. /*中断服务程序应该是与中断号一一对应的*/
  105. /*对应于某个中断号的中断一发生,就会调用该中断号对应的服务程序*/
  106. /*那么,检测中断的发生,就成了先决条件*/
  107. /*参数dev_id ---具体是哪一个按钮*/
  108. static irqreturn_t buttons_interrupt(int irq,void *dev_id);

  110. /*mini2440_buttons_open()函数申明*/
  111. /*驱动函数open调用的具体函数*/
  112. /*由open函数具体实现硬件的初始化工作*/
  113. /*以及软件的初始化工作*/
  114. /*为我们的键盘设备的运行创造好环境*/
  115. static int mini2440_buttons_open(struct inode *inode,struct file *file);

  117. /*mini2440_buttons_close()函数的申明*/
  118. /*release调用的具体函数*/
  119. /*设备软件环境的拆卸*/
  120. /*具体就是中断的释放工作*/
  121. /*因为中断资源,也是系统宝贵的资源,所以不用的时候,要释放*/
  122. static int mini2440_buttons_close(struct inode *inode,struct file *file);

  124. /*mini2440_buttons_read()函数的申明*/
  125. /*read调用的具体函数*/
  126. /*由它读取键盘输入的结果*/
  127. /*实质上就是读取key_values数组的值*/
  128. /*它完成了键盘作为输入设备的核心功能*/
  129. /*数组是否可读,要根据标志位ev_press来判断*/
  130. /*如果数组可读,则读取数据到用户buffer中*/
  131. /*如果数组不可读,则进程进入等待队列,等待到数组可读为止*/
  132. /*等待队列机制,是中断管理中常用到的机制*/
  133. /*因为有些进程经常需要等待某一事件的发生*/
  134. static int mini2440_buttons_read(struct file *filp,char __user *buff,size_t count,loff_t *offp);
  135.         /*注意__user,指的是用户空间*/
  136.         /*即要把键盘的输入结果读取到用户空间去*/

  138. /*mini2440_buttons_poll()函数的申明*/
  139. /*poll调用的具体函数*/
  140. /*poll实质上是select的调用函数*/
  141. /*如果有按键数据,则select会立刻返回*/
  142. /*如果没有按键数据,则等待*/
  143. /*实质上这是键盘等待输入的机制*/
  144. static unsigned int mini2440_buttons_poll(struct file *file,struct poll_table_struct *wait);


  147. /*file_operations结构体*/
  148. /*驱动函数的设置*/
  149. /*分别将前面的驱动函数设置进来*/
  150. static struct file_operations mini2440_buttons_fops =
  151. {
  152. .owner = THIS_MODULE,
  153. .open = mini2440_buttons_open, /*open()*/
  154. .release = mini2440_buttons_close, /*release()*/
  155. .read = mini2440_buttons_read, /*read()*/
  156. .poll = mini2440_buttons_poll /*poll()*/
  157. };

  159. /*mini2440_buttons_init()函数的申明*/
  160. /*module_init调用的具体函数*/
  161. /*模块创建时的初始化函数*/
  162. /*主要做的工作是注册设备和创建设备*/
  163. /*而具体的硬件初始化工作,它可以不做*/
  164. /*而把它留给fops里的函数来做*/
  165. static int __init mini2440_buttons_init(void);

  167. /*mini2440_buttons_exit()函数的申明*/
  168. /*模块卸载时的扫尾工作*/
  169. /*主要是设备的卸载工作*/
  170. static void __exit mini2440_buttons_exit(void);

  172. /*模块创建时的入口点*/
  173. module_init(mini2440_buttons_init);

  175. /*模块卸载时的入口点*/
  176. module_exit(mini2440_buttons_exit);
  177. /*驱动程序的一些信息*/
  178. MODULE_AUTHOR("http://www.arm9.net"); /*驱动程序的作者*/
  179. MODULE_DESCRIPTION("S3C2410/S3C2440 BUTTON Driver"); /*描述信息*/
  180. MODULE_LICENSE("GPL"); /*遵循的协议*/

复制代码
按键, 寄存器, 程序, 资源

最新回复

daicheng
不错，项一下！  详情 回复 发表于 2009-9-7 11:38
点赞 关注
嵌入式论坛  嵌入式开发  嵌入式技术  嵌入式教程
回复
举报
bootloader

121

帖子

2642

TA的资源

纯净的硅（中级）
沙发
 楼主| 发表于2009-9-7 10:34 只看该作者
 
  1. /********************************************************************/
  2. /*********************下面是前面申明函数的实现***********************/
  3. /********************************************************************/


  6. /**********************mini2440_buttons_init()***********************/

  8. static int __init mini2440_buttons_init(void)
  9. {
  10. int ret; /*设备注册的返回值*/

  12. /*注册设备驱动程序*/
  13. /*设备号,设备名,和驱动函数*/

  15. ret = register_chrdev(BUTTON_MAJOR,DEVICE_NAME,&mini2440_buttons_fops);

  17. /*对注册失败的处理*/

  19. if(ret < 0)
  20. {
  21. printk(DEVICE_NAME " can't register major number\n");
  22. return ret;
  23. }

  25. /*创建设备*/
  26. /*devfs_mk_cdev()函数是内核态的设备创建函数*/
  27. /*而mknod是用户态的设备创建函数*/

  29. devfs_mk_cdev(MKDEV(BUTTON_MAJOR,0),S_IFCHR | S_IRUSR | S_IWUSR | S_IRGRP,DEVICE_NAME);

  31. printk(DEVICE_NAME " initialized\n");

  33. return 0;
  34. }


  37. /******************mini2440_buttons_exit()****************************/

  39. static void __exit mini2440_buttons_exit(void)
  40. {
  41. /*移除设备*/

  43. devfs_remove(DEVICE_NAME);

  45. /*注消设备驱动*/

  47. unregister_chrdev(BUTTON_MAJOR,DEVICE_NAME);
  48. }


  51. /*****************mini2440_buttons_open()******************************/

  53. static int mini2440_buttons_open(struct inode *inode,struct file *file)
  54. {
  55. int i; /*循环变量,因为有6个按钮*/

  57. int err; /*中断注册函数的返回值*/

  59. /*对每个按钮分别处理,用for循环来做*/
  60. /*具体地是要联结寄存器和相应的引脚*/
  61. /*联结中断号和相应的中断服务程序*/
  62. /*这一步类似于前面所说的驱动的注册*/
  63. /*我们可以成功称作中断的注册*/

  65. for(i = 0;i < sizeof(button_irqs)/sizeof(button_irqs[0]);i++)
  66. {
  67. /*寄存器与中断引脚的联结*/

  69. s3c2410_gpio_cfgpin(button_irqs[i].pin,button_irqs[i].pin_setting);

  71. /*中断的注册*/
  72. /*request_irq()函数*/
  73. /*要注意其输入参数*/
  74. /*&button_irqs[i]是该中断享有的资源*/
  75. /*会被传入buttons_interrupt,进行处理*/

  77. err = request_irq(button_irqs[i].irq,buttons_interrupt,NULL,button_irqs[i].name,(void *)&button_irqs[i]);

  79. /*中断类型的设置*/
  80. /*set_irq_type()函数*/
  81. /*IRQT_BOTHEDGE的中断类型代表什么样的中断呢?*/

  83. /*有几个非常重要的问题*/
  84. /*中断注册后,并设置好其中断类型之后,当有中断发生时,*/
  85. /*即按下某个按钮时,系统能够自动检测到有中断发生吗?*/
  86. /*检测到有中断发生,它能够自动辨别是几号中断吗?*/
  87. /*知道了是几号中断,那么它能自动调用其中断服务程序吗?*/
  88. /*对这几个问题的解答,够成了linux系统中断处理机制的核心*/

  90. set_irq_type(button_irqs[i].irq,IRQT_BOTHEDGE);

  92. /*注册失败的处理*/

  94. if(err)
  95. break; /*跳出循环*/
  96. }

  98. /*若有一个按钮中断注册失败*/
  99. /*则还需把前面注册成功的中断给拆了*/

  101. if(err)
  102. {
  103. i--; /*回到前面一个按钮的处理*/

  105. for(;i >=0; i--) /*依此拆除*/
  106. {
  107. /*使中断不起作用*/

  109. disable_irq(button_irqs[i].irq);

  111. /*释放中断资源*/

  113. free_irq(button_irqs[i].irq,(void *)&button_irqs[i]);
  114. }

  116. return -EBUSY; /*中断注册没成功的最终的返回值*/
  117. }

  119. return 0; /*正常返回*/
  120. }


  123. /**************************buttons_interrupt()*****************************/
  124. /*此中断服务程序,在每中断一次,就要对key_values数组设一下值*/
  125. /*并对数组可读标志位ev_press设一下值*/
  126. /*并唤醒在等待队列里的进程*/
  127. /*这是中断处理经常要做的事情*/
  128. /*在这里,等待队列button_waitq里经常等待的进程是数组的读取进程*/
  129. /*就是说,读取进程在没有读到数据的时候就一直在等待,等待按键的输入*/
  130. /*读取进程在等待,并不代表所有进程在等待,其它进程该干啥干啥去*/

  132. static irqreturn_t buttons_interrupt(int irq,void *dev_id)
  133. {
  134. /*button_irq_desc结构体变量*/
  135. /*对传入的资源进行处理*/

  137. struct button_irq_desc *button_irqs = (struct button_irq_desc *)dev_id;

  139. /*获取寄存器的值*/
  140. /*这一步至关重要*/
  141. /*s3c2410_gpio_getpin()函数直接获取寄存器的值*/

  143. /*要注意,按一下按钮，会发生两次中断*/

  145. /*即按下是一次中断，放开又是一次中断*/


  148. int up = s3c2410_gpio_getpin(button_irqs->pin);

  150. /*通过电路原理图,可以知道没按下的时候,中断引脚应该是高电平*/
  151. /*从而寄存器的值应该是1*/
  152. /*变量取up也是有意义的,表示默认状态是弹起的状态*/
  153. /*当按下按钮的状态下,寄存器的值就应该是0*/

  155. /*下面对up的值进行处理*/
  156. /*即是要把数据经过一定的变换存入key_values数组中*/

  158. if(up) /*如果是弹起的状态*/
  159. /*那么就要在key_values数组的相应位存入很大的一个值*/
  160. /*同时又要能从值里辨别出是哪个按键*/

  162. key_values[button_irqs->number] = (button_irqs->number + 1) + 0x80;
  163. /*比如K1键开启的状态下,key_values[0]被置为(0+1)+0x80,即为129*/

  165. else /*如果按键是闭合的状态*/
  166. /*那么就要在key_values数组的相应位存入一个很小的数*/
  167. /*同时又要能从值中辨别出是哪个键*/

  169. key_values[button_irqs->number] = (button_irqs->number + 1);
  170. /*比如K1键闭合,则key_values[0]被置为(0+1),即为1*/

  172. /*对数组可读标志位进行设置*/

  174. ev_press = 1; /*表示数组已经可读了*/

  176. /*唤醒休眠的进程?*/
  177. /*button_waitq队列里存放有相应的处理进程*/
  178. /*如读取数组的值的进程*/
  179. /*要注意wake_up_interruptible()这些函数的用法*/

  181. wake_up_interruptible(&button_waitq);

  183. /*返回*/

  185. return IRQ_RETVAL(IRQ_HANDLED); /*?*/
  186. }

  188. /**********************mini2440_buttons_close()*****************************/

  190. static int mini2440_buttons_close(struct inode *inode,struct file *file)
  191. {
  192. int i; /*循环变量,要操作好几个按键*/

  194. /*for循环,对各个按键依此释放中断*/

  196. for(i = 0;i < sizeof(button_irqs)/sizeof(button_irqs[0]);i++)
  197. {
  198. /*使中断失效*/

  200. disable_irq(button_irqs[i].irq);

  202. /*释放资源*/

  204. free_irq(button_irqs[i].irq,(void *)&button_irqs[i]);
  205. }

  207. /*返回*/

  209. return 0;
  210. }


  213. /**********************mini2440_buttons_read()***************************/

  215. /*要注意,该read函数,只读取一次中断的值,而不是连续地读入*/
  216. /*要做到连续地读入,则需要做一个循环,不断地调用该read函数,但那不是驱动程序里该做的事情*/

  218. static int mini2440_buttons_read(struct file *filp,char __user *buff,size_t count,loff_t *offp)
  219. {
  220. unsigned long err; /*copy_to_user()函数的返回值*/

  222. /*如果key_values 数组里没有值,则会此进程会休眠*/
  223. /*一直到中断来临之后,中断服务程序会唤醒此休眠进程从而继续读取值*/
  224. /*key_values数组里有没有值,是靠ev_press标志位来判断的*/
  225. /*有值,就是1,无值,就是0*/

  227. /*进程等待队列的机制,是进程调度的一种方法*/

  229. if(!ev_press) /*标志位为0,即无数据时*/
  230. {
  231. if(filp->f_flags & O_NONBLOCK) /*??*/
  232. return -EAGAIN;
  233. else /*进程休眠,放进button_waitq等待队列*/
  234. /*这里,把ev_press标志位设成了休眠进程的标志位了?*/
  235. /*这是为了便于利用poll_wait函数*/
  236. /*也就是利于select函数*/
  237. wait_event_interruptible(button_waitq,ev_press);
  238. /*在中断处理函数中,此进程会被唤醒*/
  239. /*唤醒前,ev_press 已被置1了*/
  240. /*唤醒后的执行点从这里开始*/
  241. }

  243. /*下面就是标志位为1,即有数据可读的的处理情况*/

  245. /*那就开始往用户空间读数据呗*/

  247. err = copy_to_user(buff,(const void *)key_values,min(sizeof(key_values),count));
  248. /*copy_to_user()函数的使用*/

  250. /*对key_values数组清零*/

  252. memset((void *)key_values,0,sizeof(key_values));

  254. /*对标志位置0*/
  255. /*表示读取过了*/

  257. ev_press = 0;

  259. /*对err的处理*/

  261. if(err) /*读取错误*/
  262. return -EFAULT;
  263. else /*读取正确*/
  264. /*则返回读取到的字节数*/
  265. return min(sizeof(key_values),count);
  266. }


  269. /************************mini2440_buttons_poll()***********************/

  271. static unsigned int mini2440_buttons_poll(struct file *file,struct poll_table_struct *wait)
  272. {
  273. unsigned int mask = 0; /* */

  275. /*poll_wait()函数*/
  276. /*会监测进程队列button_waitq里的进程*/
  277. /*例如,如果mini2440_button_read所在的进程的标志位ev_press置为1了*/
  278. /*那么就不会再等待了*/
  279. /*这实质上就是select函数的运行机制*/

  281. poll_wait(file,&button_waitq,wait);

  283. if(ev_press)
  284. mask |= POLLIN | POLLRDNORM; /*??*/

  286. return mask;
  287. }

  289. ==================================================================================

  291. 下面是测试代码：
  292. /*按键测试程序*/

  294. #include /*标准输入输出头文件*/

  296. #include /*标准库*/

  298. #include /*一些宏的定义在这里*/

  300. #include /*设备的控制*/

  302. #include /*定义了一些类型*/

  304. #include /*状态*/

  306. #include /*文件控制*/

  308. #include /*选择?*/

  310. #include /*时间方面的函数*/

  312. #include /*有关错误方面的宏*/

  314. /*主函数入口*/

  316. int main(void)
  317. {
  318. int i; /*键盘输出时用到的循环变量*/

  320. int buttons_fd; /*buttons设备号*/

  322. int key_value[4]; /*四个按键的取值*/

  324. /*打开键盘设备文件*/

  326. buttons_fd = open("/dev/buttons",0); /*以0方式打开*/

  328. /*打开出错处理*/

  330. if(buttons_fd < 0) /*打开出错就会返回一个负值*/
  331. {
  332. perror("open device buttons"); /*perror函数?*/

  334. exit(1); /*返回1*/
  335. }

  337. /*for无限循环,等待用户输入*/
  338. /*这是很典型的程序执行方式*/

  340. for(;;)
  341. {
  342. fd_set rds; /*fd_set是types.h中定义的类型,实质上是int型*/
  343. /*rds用来存储设备号*/

  345. int ret; /*for循环内定义的局部变量ret*/

  347. FD_ZERO(&rds); /*rds初始化*/
  348. /*FD_ZERO是哪里定义的呢?*/

  350. FD_SET(buttons_fd,&rds); /*将buttons设备号赋给rds*/
  351. /*FD_SET是哪里定义的呢?*/

  353. /*使用系统调用select检查是否能够从/dev/buttons设备读取数据*/
  354. /*select函数是干什么的呢?*/

  356. ret = select(buttons_fd + 1,&rds,NULL,NULL,NULL);
  357. /*返回值ret*/
  358. /*返回值的具体意义是什么呢?*/

  360. /*对ret的处理*/

  362. if(ret < 0) /*当ret小于0*/
  363. {
  364. perror("select");
  365. exit(1);
  366. }

  368. if(ret == 0) /*当ret等于0*/
  369. {
  370. printf("Timeout.\n");
  371. }
  372. else /*能够读到数据*/
  373. if(FD_ISSET(buttons_fd,&rds)) /*??*/
  374. {
  375. /*读取键盘驱动发出的数据*/
  376. /*key_value和键盘驱动中定义一致*/

  378. int ret = read(buttons_fd,key_value,sizeof(key_value)); /*注意此处的ret和前面的ret有何不同*/
  379. /*注意键盘设备读取的特点*/

  381. /*对ret的处理*/
  382. if(ret != sizeof(key_value)) /*没有接收够*/
  383. {
  384. if(errno != EAGAIN) /*???*/
  385. perror("read buttons\n");
  386. continue;
  387. }
  388. else /*正确接收,则打印到标准终端*/
  389. {
  390. for(i = 0;i < 4;i++) /*最开始定义的循环变量i*/
  391. printf("K%d %s, key value = 0x%02x\n",i,(key_value[i] & 0x80) ? "released" : key_value[i] ? "pressed down" : "",key_value[i]);
  392. /*这一连串的输出,要注意格式*/
  393. }
  394. }
  395. }

  397. /*关闭设备*/

  399. close(buttons_fd);

  401. return 0; /*主函数返回*/
  402. ｝

  404. END！！








  413. 原文地址 http://hi.baidu.com/zhxust/blog/item/26b07c3ec76370f2828b13a3.html?
复制代码
 
 
嵌入式培训  嵌入式系统  嵌入式学习
回复
举报
daicheng

2131

帖子

0

TA的资源

至上芯片
板凳
发表于2009-9-7 11:38 只看该作者
 
不错，项一下！
 
个人签名处处留心皆学问！
 
 
回复
举报
返回列表 发新帖 回复
您需要登录后才可以回帖 登录 | 注册

活动 更多>>
开源项目 更多>>
随便看看
查找数据手册?
搜索

EEWorld Datasheet 技术支持

热门标签
相关文章 更多>>
新帖速递
关闭
站长推荐上一条 1/7 下一条

 
EEWorld订阅号

 
EEWorld服务号

 
汽车开发圈

About Us 关于我们 客户服务 联系方式 器件索引 网站地图 最新更新 手机版

站点相关： 国产芯 安防电子 汽车电子 手机便携 工业控制 家用电子 医疗电子 测试测量 网络通信 物联网

用户热搜：

北京市海淀区中关村大街18号B座15层1530室 电话:(010)82350740 邮编：100190

电子工程世界版权所有 京B2-20211791 京ICP备10001474号-1 电信业务审批[2006]字第258号函 京公网安备 11010802033920号 Copyright © 2005-2025 EEWORLD.com.cn, Inc. All rights reserved
快速回复 返回顶部 返回列表