嵌入式Linux之我行——按键驱动在2440上的实例开发（带去抖动）

最新推荐文章于 2021-04-29 16:17:15 发布
最新推荐文章于 2021-04-29 16:17:15 发布
阅读量143 收藏
点赞数


4.将按键驱动代码部署到内核中。
 

#cp -f my2440_buttons.c /linux-2.6.30.4/drivers/char //把驱动源码复制到内核驱动的字符设备下


#gedit /linux-2.6.30.4/drivers/char/Kconfig //添加按键设备配置

config MY2440_BUTTONS
    tristate "My2440 Buttons Device"
    depends on ARCH_S3C2440
    default y
    ---help---
      My2440 User Buttons


#gedit /linux-2.6.30.4/drivers/char/Makefile //添加按键设备配置

obj-$(CONFIG_MY2440_BUTTONS) += my2440_buttons.o


5.配置内核，选择按键设备选项

#make menuconfig

Device Drivers --->
    Character devices ---> 
        <*> My2440 Buttons Device (NEW)


6. 编译内核并下载到开发板上，查看已加载的设备：#cat /proc/devices，可以看到my2440_buttons的主设备号为232

7.编写应用程序测试按键驱动，文件名：buttons_test.c

#include <stdio.h>
#include <stdlib.h>
#include <errno.h>

int main(int argc, char **argv)
{
    int fd;
    int key_status[6];

    //以阻塞方式打开设备文件，非阻塞时flags=O_NONBLOCK
    fd = open("/dev/my2440_buttons", 0);

    if(fd < 0)
    {
        printf("Open Buttons Device Faild!\n");
        exit(1);
    }

    while(1)
    {
        int i;
        int ret;
        fd_set rds;
        
        FD_ZERO(&rds);
        FD_SET(fd, &rds);
        
        //应用程序进行轮询，查询是否可对设备进行访问
        ret = select(fd + 1, &rds, NULL, NULL, NULL);
        
        if(ret < 0)
        {
            printf("Read Buttons Device Faild!\n");
            exit(1);
        }
        
        if(ret == 0)
        {
            printf("Read Buttons Device Timeout!\n");
        }
        else if(FD_ISSET(fd, &rds))
        {
            //读设备
            ret = read(fd, key_status, sizeof(key_status));

            if(ret != sizeof(key_status))
            {
                if(errno != EAGAIN)
                {
                    printf("Read Button Device Faild!\n");
                }

                continue;
            }
            else
            {
                for(i = 0; i < 6; i++)
                {
                    //对应驱动中按键的状态，为0即按键被按下
                    if(key_status[i] == 0)
                    {
                        printf("Key%d DOWN\n", i + 1);
                    }
                }
            }
        }
    }

    close(fd);

    return 0;
}


8.在开发主机上交叉编译测试应用程序，并复制到文件系统的/usr/sbin目录下，然后重新编译文件系统下载到开发板上

#arm-linux-gcc -o buttons_test buttons_test.c


9. 在开发板上的文件系统中创建一个按键设备的节点，然后运行测试程序，效果图如下，观测按开发板上的按键时，在串口工具中会输出对应按键被按下的信息，也不会出现抖动现象（即按某个按键时，不会多次产生该按键按下的情况）

三、补充问题

1.当我们启动开发板后，按键驱动就会被自动加载，这个时候，我们执行#cat /proc/interrupts命令查看系统当前使用的中断情况，没有发现有按键的中断，这是为什么？看看我们的驱动代码就知道了，原来，按键驱动中的中断申请是在设备打开里面，这个时候设备只加载了还没有打开，所以这里还没有

2.修改驱动代码，把中断的申请放到设备初始化加载里面（即将open中所有的代码移到button_init中），再来看看系统中断使用的情况，按键的中断就出现了。52、55、57、58、59、63分别为6个按键的中断号，KEY0~KEY5按键名称就是驱动中提到注意的地方（注意这个名称，在后面的一个现象中会出现），就是在这里出现了

 
4.将按键驱动代码部署到内核中。
 

#cp -f my2440_buttons.c /linux-2.6.30.4/drivers/char //把驱动源码复制到内核驱动的字符设备下


#gedit /linux-2.6.30.4/drivers/char/Kconfig //添加按键设备配置

config MY2440_BUTTONS
    tristate "My2440 Buttons Device"
    depends on ARCH_S3C2440
    default y
    ---help---
      My2440 User Buttons


#gedit /linux-2.6.30.4/drivers/char/Makefile //添加按键设备配置

obj-$(CONFIG_MY2440_BUTTONS) += my2440_buttons.o


5.配置内核，选择按键设备选项

#make menuconfig

Device Drivers --->
    Character devices ---> 
        <*> My2440 Buttons Device (NEW)


6. 编译内核并下载到开发板上，查看已加载的设备：#cat /proc/devices，可以看到my2440_buttons的主设备号为232

7.编写应用程序测试按键驱动，文件名：buttons_test.c

#include <stdio.h>
#include <stdlib.h>
#include <errno.h>

int main(int argc, char **argv)
{
    int fd;
    int key_status[6];

    //以阻塞方式打开设备文件，非阻塞时flags=O_NONBLOCK
    fd = open("/dev/my2440_buttons", 0);

    if(fd < 0)
    {
        printf("Open Buttons Device Faild!\n");
        exit(1);
    }

    while(1)
    {
        int i;
        int ret;
        fd_set rds;
        
        FD_ZERO(&rds);
        FD_SET(fd, &rds);
        
        //应用程序进行轮询，查询是否可对设备进行访问
        ret = select(fd + 1, &rds, NULL, NULL, NULL);
        
        if(ret < 0)
        {
            printf("Read Buttons Device Faild!\n");
            exit(1);
        }
        
        if(ret == 0)
        {
            printf("Read Buttons Device Timeout!\n");
        }
        else if(FD_ISSET(fd, &rds))
        {
            //读设备
            ret = read(fd, key_status, sizeof(key_status));

            if(ret != sizeof(key_status))
            {
                if(errno != EAGAIN)
                {
                    printf("Read Button Device Faild!\n");
                }

                continue;
            }
            else
            {
                for(i = 0; i < 6; i++)
                {
                    //对应驱动中按键的状态，为0即按键被按下
                    if(key_status[i] == 0)
                    {
                        printf("Key%d DOWN\n", i + 1);
                    }
                }
            }
        }
    }

    close(fd);

    return 0;
}


8.在开发主机上交叉编译测试应用程序，并复制到文件系统的/usr/sbin目录下，然后重新编译文件系统下载到开发板上

#arm-linux-gcc -o buttons_test buttons_test.c


9. 在开发板上的文件系统中创建一个按键设备的节点，然后运行测试程序，效果图如下，观测按开发板上的按键时，在串口工具中会输出对应按键被按下的信息，也不会出现抖动现象（即按某个按键时，不会多次产生该按键按下的情况）

三、补充问题

1.当我们启动开发板后，按键驱动就会被自动加载，这个时候，我们执行#cat /proc/interrupts命令查看系统当前使用的中断情况，没有发现有按键的中断，这是为什么？看看我们的驱动代码就知道了，原来，按键驱动中的中断申请是在设备打开里面，这个时候设备只加载了还没有打开，所以这里还没有

2.修改驱动代码，把中断的申请放到设备初始化加载里面（即将open中所有的代码移到button_init中），再来看看系统中断使用的情况，按键的中断就出现了。52、55、57、58、59、63分别为6个按键的中断号，KEY0~KEY5按键名称就是驱动中提到注意的地方（注意这个名称，在后面的一个现象中会出现），就是在这里出现了

 



4.将按键驱动代码部署到内核中。
 

#cp -f my2440_buttons.c /linux-2.6.30.4/drivers/char //把驱动源码复制到内核驱动的字符设备下


#gedit /linux-2.6.30.4/drivers/char/Kconfig //添加按键设备配置

config MY2440_BUTTONS
    tristate "My2440 Buttons Device"
    depends on ARCH_S3C2440
    default y
    ---help---
      My2440 User Buttons


#gedit /linux-2.6.30.4/drivers/char/Makefile //添加按键设备配置

obj-$(CONFIG_MY2440_BUTTONS) += my2440_buttons.o


5.配置内核，选择按键设备选项

#make menuconfig

Device Drivers --->
    Character devices ---> 
        <*> My2440 Buttons Device (NEW)


6. 编译内核并下载到开发板上，查看已加载的设备：#cat /proc/devices，可以看到my2440_buttons的主设备号为232

7.编写应用程序测试按键驱动，文件名：buttons_test.c

#include <stdio.h>
#include <stdlib.h>
#include <errno.h>

int main(int argc, char **argv)
{
    int fd;
    int key_status[6];

    //以阻塞方式打开设备文件，非阻塞时flags=O_NONBLOCK
    fd = open("/dev/my2440_buttons", 0);

    if(fd < 0)
    {
        printf("Open Buttons Device Faild!\n");
        exit(1);
    }

    while(1)
    {
        int i;
        int ret;
        fd_set rds;
        
        FD_ZERO(&rds);
        FD_SET(fd, &rds);
        
        //应用程序进行轮询，查询是否可对设备进行访问
        ret = select(fd + 1, &rds, NULL, NULL, NULL);
        
        if(ret < 0)
        {
            printf("Read Buttons Device Faild!\n");
            exit(1);
        }
        
        if(ret == 0)
        {
            printf("Read Buttons Device Timeout!\n");
        }
        else if(FD_ISSET(fd, &rds))
        {
            //读设备
            ret = read(fd, key_status, sizeof(key_status));

            if(ret != sizeof(key_status))
            {
                if(errno != EAGAIN)
                {
                    printf("Read Button Device Faild!\n");
                }

                continue;
            }
            else
            {
                for(i = 0; i < 6; i++)
                {
                    //对应驱动中按键的状态，为0即按键被按下
                    if(key_status[i] == 0)
                    {
                        printf("Key%d DOWN\n", i + 1);
                    }
                }
            }
        }
    }

    close(fd);

    return 0;
}


8.在开发主机上交叉编译测试应用程序，并复制到文件系统的/usr/sbin目录下，然后重新编译文件系统下载到开发板上

#arm-linux-gcc -o buttons_test buttons_test.c


9. 在开发板上的文件系统中创建一个按键设备的节点，然后运行测试程序，效果图如下，观测按开发板上的按键时，在串口工具中会输出对应按键被按下的信息，也不会出现抖动现象（即按某个按键时，不会多次产生该按键按下的情况）

三、补充问题

1.当我们启动开发板后，按键驱动就会被自动加载，这个时候，我们执行#cat /proc/interrupts命令查看系统当前使用的中断情况，没有发现有按键的中断，这是为什么？看看我们的驱动代码就知道了，原来，按键驱动中的中断申请是在设备打开里面，这个时候设备只加载了还没有打开，所以这里还没有

2.修改驱动代码，把中断的申请放到设备初始化加载里面（即将open中所有的代码移到button_init中），再来看看系统中断使用的情况，按键的中断就出现了。52、55、57、58、59、63分别为6个按键的中断号，KEY0~KEY5按键名称就是驱动中提到注意的地方（注意这个名称，在后面的一个现象中会出现），就是在这里出现了

 


4.将按键驱动代码部署到内核中。
 

#cp -f my2440_buttons.c /linux-2.6.30.4/drivers/char //把驱动源码复制到内核驱动的字符设备下


#gedit /linux-2.6.30.4/drivers/char/Kconfig //添加按键设备配置

config MY2440_BUTTONS
    tristate "My2440 Buttons Device"
    depends on ARCH_S3C2440
    default y
    ---help---
      My2440 User Buttons


#gedit /linux-2.6.30.4/drivers/char/Makefile //添加按键设备配置

obj-$(CONFIG_MY2440_BUTTONS) += my2440_buttons.o


5.配置内核，选择按键设备选项

#make menuconfig

Device Drivers --->
    Character devices ---> 
        <*> My2440 Buttons Device (NEW)


6. 编译内核并下载到开发板上，查看已加载的设备：#cat /proc/devices，可以看到my2440_buttons的主设备号为232

7.编写应用程序测试按键驱动，文件名：buttons_test.c

#include <stdio.h>
#include <stdlib.h>
#include <errno.h>

int main(int argc, char **argv)
{
    int fd;
    int key_status[6];

    //以阻塞方式打开设备文件，非阻塞时flags=O_NONBLOCK
    fd = open("/dev/my2440_buttons", 0);

    if(fd < 0)
    {
        printf("Open Buttons Device Faild!\n");
        exit(1);
    }

    while(1)
    {
        int i;
        int ret;
        fd_set rds;
        
        FD_ZERO(&rds);
        FD_SET(fd, &rds);
        
        //应用程序进行轮询，查询是否可对设备进行访问
        ret = select(fd + 1, &rds, NULL, NULL, NULL);
        
        if(ret < 0)
        {
            printf("Read Buttons Device Faild!\n");
            exit(1);
        }
        
        if(ret == 0)
        {
            printf("Read Buttons Device Timeout!\n");
        }
        else if(FD_ISSET(fd, &rds))
        {
            //读设备
            ret = read(fd, key_status, sizeof(key_status));

            if(ret != sizeof(key_status))
            {
                if(errno != EAGAIN)
                {
                    printf("Read Button Device Faild!\n");
                }

                continue;
            }
            else
            {
                for(i = 0; i < 6; i++)
                {
                    //对应驱动中按键的状态，为0即按键被按下
                    if(key_status[i] == 0)
                    {
                        printf("Key%d DOWN\n", i + 1);
                    }
                }
            }
        }
    }

    close(fd);

    return 0;
}


8.在开发主机上交叉编译测试应用程序，并复制到文件系统的/usr/sbin目录下，然后重新编译文件系统下载到开发板上

#arm-linux-gcc -o buttons_test buttons_test.c


9. 在开发板上的文件系统中创建一个按键设备的节点，然后运行测试程序，效果图如下，观测按开发板上的按键时，在串口工具中会输出对应按键被按下的信息，也不会出现抖动现象（即按某个按键时，不会多次产生该按键按下的情况）

三、补充问题

1.当我们启动开发板后，按键驱动就会被自动加载，这个时候，我们执行#cat /proc/interrupts命令查看系统当前使用的中断情况，没有发现有按键的中断，这是为什么？看看我们的驱动代码就知道了，原来，按键驱动中的中断申请是在设备打开里面，这个时候设备只加载了还没有打开，所以这里还没有

2.修改驱动代码，把中断的申请放到设备初始化加载里面（即将open中所有的代码移到button_init中），再来看看系统中断使用的情况，按键的中断就出现了。52、55、57、58、59、63分别为6个按键的中断号，KEY0~KEY5按键名称就是驱动中提到注意的地方（注意这个名称，在后面的一个现象中会出现），就是在这里出现了

 
4.将按键驱动代码部署到内核中。
 

#cp -f my2440_buttons.c /linux-2.6.30.4/drivers/char //把驱动源码复制到内核驱动的字符设备下


#gedit /linux-2.6.30.4/drivers/char/Kconfig //添加按键设备配置

config MY2440_BUTTONS
    tristate "My2440 Buttons Device"
    depends on ARCH_S3C2440
    default y
    ---help---
      My2440 User Buttons


#gedit /linux-2.6.30.4/drivers/char/Makefile //添加按键设备配置

obj-$(CONFIG_MY2440_BUTTONS) += my2440_buttons.o


5.配置内核，选择按键设备选项

#make menuconfig

Device Drivers --->
    Character devices ---> 
        <*> My2440 Buttons Device (NEW)


6. 编译内核并下载到开发板上，查看已加载的设备：#cat /proc/devices，可以看到my2440_buttons的主设备号为232

7.编写应用程序测试按键驱动，文件名：buttons_test.c

#include <stdio.h>
#include <stdlib.h>
#include <errno.h>

int main(int argc, char **argv)
{
    int fd;
    int key_status[6];

    //以阻塞方式打开设备文件，非阻塞时flags=O_NONBLOCK
    fd = open("/dev/my2440_buttons", 0);

    if(fd < 0)
    {
        printf("Open Buttons Device Faild!\n");
        exit(1);
    }

    while(1)
    {
        int i;
        int ret;
        fd_set rds;
        
        FD_ZERO(&rds);
        FD_SET(fd, &rds);
        
        //应用程序进行轮询，查询是否可对设备进行访问
        ret = select(fd + 1, &rds, NULL, NULL, NULL);
        
        if(ret < 0)
        {
            printf("Read Buttons Device Faild!\n");
            exit(1);
        }
        
        if(ret == 0)
        {
            printf("Read Buttons Device Timeout!\n");
        }
        else if(FD_ISSET(fd, &rds))
        {
            //读设备
            ret = read(fd, key_status, sizeof(key_status));

            if(ret != sizeof(key_status))
            {
                if(errno != EAGAIN)
                {
                    printf("Read Button Device Faild!\n");
                }

                continue;
            }
            else
            {
                for(i = 0; i < 6; i++)
                {
                    //对应驱动中按键的状态，为0即按键被按下
                    if(key_status[i] == 0)
                    {
                        printf("Key%d DOWN\n", i + 1);
                    }
                }
            }
        }
    }

    close(fd);

    return 0;
}


8.在开发主机上交叉编译测试应用程序，并复制到文件系统的/usr/sbin目录下，然后重新编译文件系统下载到开发板上

#arm-linux-gcc -o buttons_test buttons_test.c


9. 在开发板上的文件系统中创建一个按键设备的节点，然后运行测试程序，效果图如下，观测按开发板上的按键时，在串口工具中会输出对应按键被按下的信息，也不会出现抖动现象（即按某个按键时，不会多次产生该按键按下的情况）

三、补充问题

1.当我们启动开发板后，按键驱动就会被自动加载，这个时候，我们执行#cat /proc/interrupts命令查看系统当前使用的中断情况，没有发现有按键的中断，这是为什么？看看我们的驱动代码就知道了，原来，按键驱动中的中断申请是在设备打开里面，这个时候设备只加载了还没有打开，所以这里还没有

2.修改驱动代码，把中断的申请放到设备初始化加载里面（即将open中所有的代码移到button_init中），再来看看系统中断使用的情况，按键的中断就出现了。52、55、57、58、59、63分别为6个按键的中断号，KEY0~KEY5按键名称就是驱动中提到注意的地方（注意这个名称，在后面的一个现象中会出现），就是在这里出现了

 

4.将按键驱动代码部署到内核中。
 

#cp -f my2440_buttons.c /linux-2.6.30.4/drivers/char //把驱动源码复制到内核驱动的字符设备下


#gedit /linux-2.6.30.4/drivers/char/Kconfig //添加按键设备配置

config MY2440_BUTTONS
    tristate "My2440 Buttons Device"
    depends on ARCH_S3C2440
    default y
    ---help---
      My2440 User Buttons


#gedit /linux-2.6.30.4/drivers/char/Makefile //添加按键设备配置

obj-$(CONFIG_MY2440_BUTTONS) += my2440_buttons.o


5.配置内核，选择按键设备选项

#make menuconfig

Device Drivers --->
    Character devices ---> 
        <*> My2440 Buttons Device (NEW)


6. 编译内核并下载到开发板上，查看已加载的设备：#cat /proc/devices，可以看到my2440_buttons的主设备号为232

7.编写应用程序测试按键驱动，文件名：buttons_test.c

#include <stdio.h>
#include <stdlib.h>
#include <errno.h>

int main(int argc, char **argv)
{
    int fd;
    int key_status[6];

    //以阻塞方式打开设备文件，非阻塞时flags=O_NONBLOCK
    fd = open("/dev/my2440_buttons", 0);

    if(fd < 0)
    {
        printf("Open Buttons Device Faild!\n");
        exit(1);
    }

    while(1)
    {
        int i;
        int ret;
        fd_set rds;
        
        FD_ZERO(&rds);
        FD_SET(fd, &rds);
        
        //应用程序进行轮询，查询是否可对设备进行访问
        ret = select(fd + 1, &rds, NULL, NULL, NULL);
        
        if(ret < 0)
        {
            printf("Read Buttons Device Faild!\n");
            exit(1);
        }
        
        if(ret == 0)
        {
            printf("Read Buttons Device Timeout!\n");
        }
        else if(FD_ISSET(fd, &rds))
        {
            //读设备
            ret = read(fd, key_status, sizeof(key_status));

            if(ret != sizeof(key_status))
            {
                if(errno != EAGAIN)
                {
                    printf("Read Button Device Faild!\n");
                }

                continue;
            }
            else
            {
                for(i = 0; i < 6; i++)
                {
                    //对应驱动中按键的状态，为0即按键被按下
                    if(key_status[i] == 0)
                    {
                        printf("Key%d DOWN\n", i + 1);
                    }
                }
            }
        }
    }

    close(fd);

    return 0;
}


8.在开发主机上交叉编译测试应用程序，并复制到文件系统的/usr/sbin目录下，然后重新编译文件系统下载到开发板上

#arm-linux-gcc -o buttons_test buttons_test.c


9. 在开发板上的文件系统中创建一个按键设备的节点，然后运行测试程序，效果图如下，观测按开发板上的按键时，在串口工具中会输出对应按键被按下的信息，也不会出现抖动现象（即按某个按键时，不会多次产生该按键按下的情况）

三、补充问题

1.当我们启动开发板后，按键驱动就会被自动加载，这个时候，我们执行#cat /proc/interrupts命令查看系统当前使用的中断情况，没有发现有按键的中断，这是为什么？看看我们的驱动代码就知道了，原来，按键驱动中的中断申请是在设备打开里面，这个时候设备只加载了还没有打开，所以这里还没有

2.修改驱动代码，把中断的申请放到设备初始化加载里面（即将open中所有的代码移到button_init中），再来看看系统中断使用的情况，按键的中断就出现了。52、55、57、58、59、63分别为6个按键的中断号，KEY0~KEY5按键名称就是驱动中提到注意的地方（注意这个名称，在后面的一个现象中会出现），就是在这里出现了

 



4.将按键驱动代码部署到内核中。
 
#cp -f my2440_buttons.c /linux-2.6.30.4/drivers/char //把驱动源码复制到内核驱动的字符设备下


#gedit /linux-2.6.30.4/drivers/char/Kconfig //添加按键设备配置
config MY2440_BUTTONS
    tristate "My2440 Buttons Device"
    depends on ARCH_S3C2440
    default y
    ---help---
      My2440 User Buttons


#gedit /linux-2.6.30.4/drivers/char/Makefile //添加按键设备配置
obj-$(CONFIG_MY2440_BUTTONS) += my2440_buttons.o


5.配置内核，选择按键设备选项
#make menuconfig
Device Drivers --->
    Character devices ---> 
        <*> My2440 Buttons Device (NEW)


6. 编译内核并下载到开发板上，查看已加载的设备：#cat /proc/devices，可以看到my2440_buttons的主设备号为232


7.编写应用程序测试按键驱动，文件名：buttons_test.c
#include <stdio.h>
#include <stdlib.h>
#include <errno.h>


int main(int argc, char **argv)
{
    int fd;
    int key_status[6];


    //以阻塞方式打开设备文件，非阻塞时flags=O_NONBLOCK
    fd = open("/dev/my2440_buttons", 0);


    if(fd < 0)
    {
        printf("Open Buttons Device Faild!\n");
        exit(1);
    }


    while(1)
    {
        int i;
        int ret;
        fd_set rds;
        
        FD_ZERO(&rds);
        FD_SET(fd, &rds);
        
        //应用程序进行轮询，查询是否可对设备进行访问
        ret = select(fd + 1, &rds, NULL, NULL, NULL);
        
        if(ret < 0)
        {
            printf("Read Buttons Device Faild!\n");
            exit(1);
        }
        
        if(ret == 0)
        {
            printf("Read Buttons Device Timeout!\n");
        }
        else if(FD_ISSET(fd, &rds))
        {
            //读设备
            ret = read(fd, key_status, sizeof(key_status));


            if(ret != sizeof(key_status))
            {
                if(errno != EAGAIN)
                {
                    printf("Read Button Device Faild!\n");
                }


                continue;
            }
            else
            {
                for(i = 0; i < 6; i++)
                {
                    //对应驱动中按键的状态，为0即按键被按下
                    if(key_status[i] == 0)
                    {
                        printf("Key%d DOWN\n", i + 1);
                    }
                }
            }
        }
    }


    close(fd);


    return 0;
}


8.在开发主机上交叉编译测试应用程序，并复制到文件系统的/usr/sbin目录下，然后重新编译文件系统下载到开发板上
#arm-linux-gcc -o buttons_test buttons_test.c


9. 在开发板上的文件系统中创建一个按键设备的节点，然后运行测试程序，效果图如下，观测按开发板上的按键时，在串口工具中会输出对应按键被按下的信息，也不会出现抖动现象（即按某个按键时，不会多次产生该按键按下的情况）


三、补充问题
1.当我们启动开发板后，按键驱动就会被自动加载，这个时候，我们执行#cat /proc/interrupts命令查看系统当前使用的中断情况，没有发现有按键的中断，这是为什么？看看我们的驱动代码就知道了，原来，按键驱动中的中断申请是在设备打开里面，这个时候设备只加载了还没有打开，所以这里还没有


2.修改驱动代码，把中断的申请放到设备初始化加载里面（即将open中所有的代码移到button_init中），再来看看系统中断使用的情况，按键的中断就出现了。52、55、57、58、59、63分别为6个按键的中断号，KEY0~KEY5按键名称就是驱动中提到注意的地方（注意这个名称，在后面的一个现象中会出现），就是在这里出现了


 

4.将按键驱动代码部署到内核中。
 

#cp -f my2440_buttons.c /linux-2.6.30.4/drivers/char //把驱动源码复制到内核驱动的字符设备下


#gedit /linux-2.6.30.4/drivers/char/Kconfig //添加按键设备配置

config MY2440_BUTTONS
    tristate "My2440 Buttons Device"
    depends on ARCH_S3C2440
    default y
    ---help---
      My2440 User Buttons


#gedit /linux-2.6.30.4/drivers/char/Makefile //添加按键设备配置

obj-$(CONFIG_MY2440_BUTTONS) += my2440_buttons.o


5.配置内核，选择按键设备选项

#make menuconfig

Device Drivers --->
    Character devices ---> 
        <*> My2440 Buttons Device (NEW)


6. 编译内核并下载到开发板上，查看已加载的设备：#cat /proc/devices，可以看到my2440_buttons的主设备号为232

7.编写应用程序测试按键驱动，文件名：buttons_test.c

#include <stdio.h>
#include <stdlib.h>
#include <errno.h>

int main(int argc, char **argv)
{
    int fd;
    int key_status[6];

    //以阻塞方式打开设备文件，非阻塞时flags=O_NONBLOCK
    fd = open("/dev/my2440_buttons", 0);

    if(fd < 0)
    {
        printf("Open Buttons Device Faild!\n");
        exit(1);
    }

    while(1)
    {
        int i;
        int ret;
        fd_set rds;
        
        FD_ZERO(&rds);
        FD_SET(fd, &rds);
        
        //应用程序进行轮询，查询是否可对设备进行访问
        ret = select(fd + 1, &rds, NULL, NULL, NULL);
        
        if(ret < 0)
        {
            printf("Read Buttons Device Faild!\n");
            exit(1);
        }
        
        if(ret == 0)
        {
            printf("Read Buttons Device Timeout!\n");
        }
        else if(FD_ISSET(fd, &rds))
        {
            //读设备
            ret = read(fd, key_status, sizeof(key_status));

            if(ret != sizeof(key_status))
            {
                if(errno != EAGAIN)
                {
                    printf("Read Button Device Faild!\n");
                }

                continue;
            }
            else
            {
                for(i = 0; i < 6; i++)
                {
                    //对应驱动中按键的状态，为0即按键被按下
                    if(key_status[i] == 0)
                    {
                        printf("Key%d DOWN\n", i + 1);
                    }
                }
            }
        }
    }

    close(fd);

    return 0;
}


8.在开发主机上交叉编译测试应用程序，并复制到文件系统的/usr/sbin目录下，然后重新编译文件系统下载到开发板上

#arm-linux-gcc -o buttons_test buttons_test.c


9. 在开发板上的文件系统中创建一个按键设备的节点，然后运行测试程序，效果图如下，观测按开发板上的按键时，在串口工具中会输出对应按键被按下的信息，也不会出现抖动现象（即按某个按键时，不会多次产生该按键按下的情况）

三、补充问题

1.当我们启动开发板后，按键驱动就会被自动加载，这个时候，我们执行#cat /proc/interrupts命令查看系统当前使用的中断情况，没有发现有按键的中断，这是为什么？看看我们的驱动代码就知道了，原来，按键驱动中的中断申请是在设备打开里面，这个时候设备只加载了还没有打开，所以这里还没有

2.修改驱动代码，把中断的申请放到设备初始化加载里面（即将open中所有的代码移到button_init中），再来看看系统中断使用的情况，按键的中断就出现了。52、55、57、58、59、63分别为6个按键的中断号，KEY0~KEY5按键名称就是驱动中提到注意的地方（注意这个名称，在后面的一个现象中会出现），就是在这里出现了

 
4.将按键驱动代码部署到内核中。
 

#cp -f my2440_buttons.c /linux-2.6.30.4/drivers/char //把驱动源码复制到内核驱动的字符设备下


#gedit /linux-2.6.30.4/drivers/char/Kconfig //添加按键设备配置

config MY2440_BUTTONS
    tristate "My2440 Buttons Device"
    depends on ARCH_S3C2440
    default y
    ---help---
      My2440 User Buttons


#gedit /linux-2.6.30.4/drivers/char/Makefile //添加按键设备配置

obj-$(CONFIG_MY2440_BUTTONS) += my2440_buttons.o


5.配置内核，选择按键设备选项

#make menuconfig

Device Drivers --->
    Character devices ---> 
        <*> My2440 Buttons Device (NEW)


6. 编译内核并下载到开发板上，查看已加载的设备：#cat /proc/devices，可以看到my2440_buttons的主设备号为232

7.编写应用程序测试按键驱动，文件名：buttons_test.c

#include <stdio.h>
#include <stdlib.h>
#include <errno.h>

int main(int argc, char **argv)
{
    int fd;
    int key_status[6];

    //以阻塞方式打开设备文件，非阻塞时flags=O_NONBLOCK
    fd = open("/dev/my2440_buttons", 0);

    if(fd < 0)
    {
        printf("Open Buttons Device Faild!\n");
        exit(1);
    }

    while(1)
    {
        int i;
        int ret;
        fd_set rds;
        
        FD_ZERO(&rds);
        FD_SET(fd, &rds);
        
        //应用程序进行轮询，查询是否可对设备进行访问
        ret = select(fd + 1, &rds, NULL, NULL, NULL);
        
        if(ret < 0)
        {
            printf("Read Buttons Device Faild!\n");
            exit(1);
        }
        
        if(ret == 0)
        {
            printf("Read Buttons Device Timeout!\n");
        }
        else if(FD_ISSET(fd, &rds))
        {
            //读设备
            ret = read(fd, key_status, sizeof(key_status));

            if(ret != sizeof(key_status))
            {
                if(errno != EAGAIN)
                {
                    printf("Read Button Device Faild!\n");
                }

                continue;
            }
            else
            {
                for(i = 0; i < 6; i++)
                {
                    //对应驱动中按键的状态，为0即按键被按下
                    if(key_status[i] == 0)
                    {
                        printf("Key%d DOWN\n", i + 1);
                    }
                }
            }
        }
    }

    close(fd);

    return 0;
}


8.在开发主机上交叉编译测试应用程序，并复制到文件系统的/usr/sbin目录下，然后重新编译文件系统下载到开发板上

#arm-linux-gcc -o buttons_test buttons_test.c


9. 在开发板上的文件系统中创建一个按键设备的节点，然后运行测试程序，效果图如下，观测按开发板上的按键时，在串口工具中会输出对应按键被按下的信息，也不会出现抖动现象（即按某个按键时，不会多次产生该按键按下的情况）

三、补充问题

1.当我们启动开发板后，按键驱动就会被自动加载，这个时候，我们执行#cat /proc/interrupts命令查看系统当前使用的中断情况，没有发现有按键的中断，这是为什么？看看我们的驱动代码就知道了，原来，按键驱动中的中断申请是在设备打开里面，这个时候设备只加载了还没有打开，所以这里还没有

2.修改驱动代码，把中断的申请放到设备初始化加载里面（即将open中所有的代码移到button_init中），再来看看系统中断使用的情况，按键的中断就出现了。52、55、57、58、59、63分别为6个按键的中断号，KEY0~KEY5按键名称就是驱动中提到注意的地方（注意这个名称，在后面的一个现象中会出现），就是在这里出现了

 



4.将按键驱动代码部署到内核中。
 

#cp -f my2440_buttons.c /linux-2.6.30.4/drivers/char //把驱动源码复制到内核驱动的字符设备下


#gedit /linux-2.6.30.4/drivers/char/Kconfig //添加按键设备配置

config MY2440_BUTTONS
    tristate "My2440 Buttons Device"
    depends on ARCH_S3C2440
    default y
    ---help---
      My2440 User Buttons


#gedit /linux-2.6.30.4/drivers/char/Makefile //添加按键设备配置

obj-$(CONFIG_MY2440_BUTTONS) += my2440_buttons.o


5.配置内核，选择按键设备选项

#make menuconfig

Device Drivers --->
    Character devices ---> 
        <*> My2440 Buttons Device (NEW)


6. 编译内核并下载到开发板上，查看已加载的设备：#cat /proc/devices，可以看到my2440_buttons的主设备号为232

7.编写应用程序测试按键驱动，文件名：buttons_test.c

#include <stdio.h>
#include <stdlib.h>
#include <errno.h>

int main(int argc, char **argv)
{
    int fd;
    int key_status[6];

    //以阻塞方式打开设备文件，非阻塞时flags=O_NONBLOCK
    fd = open("/dev/my2440_buttons", 0);

    if(fd < 0)
    {
        printf("Open Buttons Device Faild!\n");
        exit(1);
    }

    while(1)
    {
        int i;
        int ret;
        fd_set rds;
        
        FD_ZERO(&rds);
        FD_SET(fd, &rds);
        
        //应用程序进行轮询，查询是否可对设备进行访问
        ret = select(fd + 1, &rds, NULL, NULL, NULL);
        
        if(ret < 0)
        {
            printf("Read Buttons Device Faild!\n");
            exit(1);
        }
        
        if(ret == 0)
        {
            printf("Read Buttons Device Timeout!\n");
        }
        else if(FD_ISSET(fd, &rds))
        {
            //读设备
            ret = read(fd, key_status, sizeof(key_status));

            if(ret != sizeof(key_status))
            {
                if(errno != EAGAIN)
                {
                    printf("Read Button Device Faild!\n");
                }

                continue;
            }
            else
            {
                for(i = 0; i < 6; i++)
                {
                    //对应驱动中按键的状态，为0即按键被按下
                    if(key_status[i] == 0)
                    {
                        printf("Key%d DOWN\n", i + 1);
                    }
                }
            }
        }
    }

    close(fd);

    return 0;
}


8.在开发主机上交叉编译测试应用程序，并复制到文件系统的/usr/sbin目录下，然后重新编译文件系统下载到开发板上

#arm-linux-gcc -o buttons_test buttons_test.c


9. 在开发板上的文件系统中创建一个按键设备的节点，然后运行测试程序，效果图如下，观测按开发板上的按键时，在串口工具中会输出对应按键被按下的信息，也不会出现抖动现象（即按某个按键时，不会多次产生该按键按下的情况）

三、补充问题

1.当我们启动开发板后，按键驱动就会被自动加载，这个时候，我们执行#cat /proc/interrupts命令查看系统当前使用的中断情况，没有发现有按键的中断，这是为什么？看看我们的驱动代码就知道了，原来，按键驱动中的中断申请是在设备打开里面，这个时候设备只加载了还没有打开，所以这里还没有

2.修改驱动代码，把中断的申请放到设备初始化加载里面（即将open中所有的代码移到button_init中），再来看看系统中断使用的情况，按键的中断就出现了。52、55、57、58、59、63分别为6个按键的中断号，KEY0~KEY5按键名称就是驱动中提到注意的地方（注意这个名称，在后面的一个现象中会出现），就是在这里出现了

 


4.将按键驱动代码部署到内核中。
 

#cp -f my2440_buttons.c /linux-2.6.30.4/drivers/char //把驱动源码复制到内核驱动的字符设备下


#gedit /linux-2.6.30.4/drivers/char/Kconfig //添加按键设备配置

config MY2440_BUTTONS
    tristate "My2440 Buttons Device"
    depends on ARCH_S3C2440
    default y
    ---help---
      My2440 User Buttons


#gedit /linux-2.6.30.4/drivers/char/Makefile //添加按键设备配置

obj-$(CONFIG_MY2440_BUTTONS) += my2440_buttons.o


5.配置内核，选择按键设备选项

#make menuconfig

Device Drivers --->
    Character devices ---> 
        <*> My2440 Buttons Device (NEW)


6. 编译内核并下载到开发板上，查看已加载的设备：#cat /proc/devices，可以看到my2440_buttons的主设备号为232

7.编写应用程序测试按键驱动，文件名：buttons_test.c

#include <stdio.h>
#include <stdlib.h>
#include <errno.h>

int main(int argc, char **argv)
{
    int fd;
    int key_status[6];

    //以阻塞方式打开设备文件，非阻塞时flags=O_NONBLOCK
    fd = open("/dev/my2440_buttons", 0);

    if(fd < 0)
    {
        printf("Open Buttons Device Faild!\n");
        exit(1);
    }

    while(1)
    {
        int i;
        int ret;
        fd_set rds;
        
        FD_ZERO(&rds);
        FD_SET(fd, &rds);
        
        //应用程序进行轮询，查询是否可对设备进行访问
        ret = select(fd + 1, &rds, NULL, NULL, NULL);
        
        if(ret < 0)
        {
            printf("Read Buttons Device Faild!\n");
            exit(1);
        }
        
        if(ret == 0)
        {
            printf("Read Buttons Device Timeout!\n");
        }
        else if(FD_ISSET(fd, &rds))
        {
            //读设备
            ret = read(fd, key_status, sizeof(key_status));

            if(ret != sizeof(key_status))
            {
                if(errno != EAGAIN)
                {
                    printf("Read Button Device Faild!\n");
                }

                continue;
            }
            else
            {
                for(i = 0; i < 6; i++)
                {
                    //对应驱动中按键的状态，为0即按键被按下
                    if(key_status[i] == 0)
                    {
                        printf("Key%d DOWN\n", i + 1);
                    }
                }
            }
        }
    }

    close(fd);

    return 0;
}


8.在开发主机上交叉编译测试应用程序，并复制到文件系统的/usr/sbin目录下，然后重新编译文件系统下载到开发板上

#arm-linux-gcc -o buttons_test buttons_test.c


9. 在开发板上的文件系统中创建一个按键设备的节点，然后运行测试程序，效果图如下，观测按开发板上的按键时，在串口工具中会输出对应按键被按下的信息，也不会出现抖动现象（即按某个按键时，不会多次产生该按键按下的情况）

三、补充问题

1.当我们启动开发板后，按键驱动就会被自动加载，这个时候，我们执行#cat /proc/interrupts命令查看系统当前使用的中断情况，没有发现有按键的中断，这是为什么？看看我们的驱动代码就知道了，原来，按键驱动中的中断申请是在设备打开里面，这个时候设备只加载了还没有打开，所以这里还没有

2.修改驱动代码，把中断的申请放到设备初始化加载里面（即将open中所有的代码移到button_init中），再来看看系统中断使用的情况，按键的中断就出现了。52、55、57、58、59、63分别为6个按键的中断号，KEY0~KEY5按键名称就是驱动中提到注意的地方（注意这个名称，在后面的一个现象中会出现），就是在这里出现了

 
4.将按键驱动代码部署到内核中。
 

#cp -f my2440_buttons.c /linux-2.6.30.4/drivers/char //把驱动源码复制到内核驱动的字符设备下


#gedit /linux-2.6.30.4/drivers/char/Kconfig //添加按键设备配置

config MY2440_BUTTONS
    tristate "My2440 Buttons Device"
    depends on ARCH_S3C2440
    default y
    ---help---
      My2440 User Buttons


#gedit /linux-2.6.30.4/drivers/char/Makefile //添加按键设备配置

obj-$(CONFIG_MY2440_BUTTONS) += my2440_buttons.o


5.配置内核，选择按键设备选项

#make menuconfig

Device Drivers --->
    Character devices ---> 
        <*> My2440 Buttons Device (NEW)


6. 编译内核并下载到开发板上，查看已加载的设备：#cat /proc/devices，可以看到my2440_buttons的主设备号为232

7.编写应用程序测试按键驱动，文件名：buttons_test.c

#include <stdio.h>
#include <stdlib.h>
#include <errno.h>

int main(int argc, char **argv)
{
    int fd;
    int key_status[6];

    //以阻塞方式打开设备文件，非阻塞时flags=O_NONBLOCK
    fd = open("/dev/my2440_buttons", 0);

    if(fd < 0)
    {
        printf("Open Buttons Device Faild!\n");
        exit(1);
    }

    while(1)
    {
        int i;
        int ret;
        fd_set rds;
        
        FD_ZERO(&rds);
        FD_SET(fd, &rds);
        
        //应用程序进行轮询，查询是否可对设备进行访问
        ret = select(fd + 1, &rds, NULL, NULL, NULL);
        
        if(ret < 0)
        {
            printf("Read Buttons Device Faild!\n");
            exit(1);
        }
        
        if(ret == 0)
        {
            printf("Read Buttons Device Timeout!\n");
        }
        else if(FD_ISSET(fd, &rds))
        {
            //读设备
            ret = read(fd, key_status, sizeof(key_status));

            if(ret != sizeof(key_status))
            {
                if(errno != EAGAIN)
                {
                    printf("Read Button Device Faild!\n");
                }

                continue;
            }
            else
            {
                for(i = 0; i < 6; i++)
                {
                    //对应驱动中按键的状态，为0即按键被按下
                    if(key_status[i] == 0)
                    {
                        printf("Key%d DOWN\n", i + 1);
                    }
                }
            }
        }
    }

    close(fd);

    return 0;
}


8.在开发主机上交叉编译测试应用程序，并复制到文件系统的/usr/sbin目录下，然后重新编译文件系统下载到开发板上

#arm-linux-gcc -o buttons_test buttons_test.c


9. 在开发板上的文件系统中创建一个按键设备的节点，然后运行测试程序，效果图如下，观测按开发板上的按键时，在串口工具中会输出对应按键被按下的信息，也不会出现抖动现象（即按某个按键时，不会多次产生该按键按下的情况）

三、补充问题

1.当我们启动开发板后，按键驱动就会被自动加载，这个时候，我们执行#cat /proc/interrupts命令查看系统当前使用的中断情况，没有发现有按键的中断，这是为什么？看看我们的驱动代码就知道了，原来，按键驱动中的中断申请是在设备打开里面，这个时候设备只加载了还没有打开，所以这里还没有

2.修改驱动代码，把中断的申请放到设备初始化加载里面（即将open中所有的代码移到button_init中），再来看看系统中断使用的情况，按键的中断就出现了。52、55、57、58、59、63分别为6个按键的中断号，KEY0~KEY5按键名称就是驱动中提到注意的地方（注意这个名称，在后面的一个现象中会出现），就是在这里出现了

 
4.将按键驱动代码部署到内核中。
 

#cp -f my2440_buttons.c /linux-2.6.30.4/drivers/char //把驱动源码复制到内核驱动的字符设备下


#gedit /linux-2.6.30.4/drivers/char/Kconfig //添加按键设备配置

config MY2440_BUTTONS
    tristate "My2440 Buttons Device"
    depends on ARCH_S3C2440
    default y
    ---help---
      My2440 User Buttons


#gedit /linux-2.6.30.4/drivers/char/Makefile //添加按键设备配置

obj-$(CONFIG_MY2440_BUTTONS) += my2440_buttons.o


5.配置内核，选择按键设备选项

#make menuconfig

Device Drivers --->
    Character devices ---> 
        <*> My2440 Buttons Device (NEW)


6. 编译内核并下载到开发板上，查看已加载的设备：#cat /proc/devices，可以看到my2440_buttons的主设备号为232

7.编写应用程序测试按键驱动，文件名：buttons_test.c

#include <stdio.h>
#include <stdlib.h>
#include <errno.h>

int main(int argc, char **argv)
{
    int fd;
    int key_status[6];

    //以阻塞方式打开设备文件，非阻塞时flags=O_NONBLOCK
    fd = open("/dev/my2440_buttons", 0);

    if(fd < 0)
    {
        printf("Open Buttons Device Faild!\n");
        exit(1);
    }

    while(1)
    {
        int i;
        int ret;
        fd_set rds;
        
        FD_ZERO(&rds);
        FD_SET(fd, &rds);
        
        //应用程序进行轮询，查询是否可对设备进行访问
        ret = select(fd + 1, &rds, NULL, NULL, NULL);
        
        if(ret < 0)
        {
            printf("Read Buttons Device Faild!\n");
            exit(1);
        }
        
        if(ret == 0)
        {
            printf("Read Buttons Device Timeout!\n");
        }
        else if(FD_ISSET(fd, &rds))
        {
            //读设备
            ret = read(fd, key_status, sizeof(key_status));

            if(ret != sizeof(key_status))
            {
                if(errno != EAGAIN)
                {
                    printf("Read Button Device Faild!\n");
                }

                continue;
            }
            else
            {
                for(i = 0; i < 6; i++)
                {
                    //对应驱动中按键的状态，为0即按键被按下
                    if(key_status[i] == 0)
                    {
                        printf("Key%d DOWN\n", i + 1);
                    }
                }
            }
        }
    }

    close(fd);

    return 0;
}


8.在开发主机上交叉编译测试应用程序，并复制到文件系统的/usr/sbin目录下，然后重新编译文件系统下载到开发板上

#arm-linux-gcc -o buttons_test buttons_test.c


9. 在开发板上的文件系统中创建一个按键设备的节点，然后运行测试程序，效果图如下，观测按开发板上的按键时，在串口工具中会输出对应按键被按下的信息，也不会出现抖动现象（即按某个按键时，不会多次产生该按键按下的情况）

三、补充问题

1.当我们启动开发板后，按键驱动就会被自动加载，这个时候，我们执行#cat /proc/interrupts命令查看系统当前使用的中断情况，没有发现有按键的中断，这是为什么？看看我们的驱动代码就知道了，原来，按键驱动中的中断申请是在设备打开里面，这个时候设备只加载了还没有打开，所以这里还没有

2.修改驱动代码，把中断的申请放到设备初始化加载里面（即将open中所有的代码移到button_init中），再来看看系统中断使用的情况，按键的中断就出现了。52、55、57、58、59、63分别为6个按键的中断号，KEY0~KEY5按键名称就是驱动中提到注意的地方（注意这个名称，在后面的一个现象中会出现），就是在这里出现了

 
Yao_Qinwei
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
嵌入式Linux之我行——S3C2440上LCD驱动(FrameBuffer)实例开发讲解（二）.doc
06-12
嵌入式Linux之我行——S3C2440上LCD驱动(FrameBuffer)实例开发讲解（二）
《linux驱动：字符设备驱动之二 中断与休眠唤醒》
qq_40709487的博客
07-10 462
linux字符设备驱动。使用中断以及休眠唤醒的方式来获取按键状态。休眠唤醒流程，相关函数DECLARE_WAIT_QUEUE_HEAD、wait_event_interruptible、wake_up_interruptible 。中断服务程序。
字符设备驱动查询方式读取按键值
2621593260的专栏
12-15 980
上一篇博文讲到通过字符型设备文件愉快的实现了控制led的亮灭，涉及到一个知识点是用户程序（用户空间）向内核程序（内核空间）发送数据实现对led的控制。今天我们是字符设备驱动之按键，要把内核程序读到的按键值发送到用户空间实现显示。 由于原理和之前类似，这里不再累述，直接看代码即可。 按键驱动程序： #include #include #include #include
linux 内核按键抖动,嵌入式Linux之我行——按键驱动在2440上的实例开发（带去抖动）...
weixin_33737110的博客
04-29 141
嵌入式Linux之我行，主要讲述和总结了本人在学习嵌入式linux中的每个步骤。一为总结经验，二希望能给想入门嵌入式Linux的朋友提供方便。如有错误之处，谢请指正。一、开发环境主 机：VMWare--Fedora 9开发板：Mini2440--64MB Nand, Kernel:2.6.30.4编译器：arm-linux-gcc-4.3.2二、实现步骤1. 硬件原理图分析。由原理图可知每个按键...
嵌入式Linux之我行——按键驱动在2440上的实例开
zhoujk0520的专栏
10-02 625
原文地址：嵌入式Linux之我行——按键驱动在2440上的实例开发（带去抖动）作者：Valley 嵌入式Linux之我行，主要讲述和总结了本人在学习嵌入式linux中的每个步骤。一为总结经验，二希望能给想入门嵌入式Linux的朋友提供方便。如有错误之处，谢请指正。
嵌入式Linux之我行——S3C2440上LCD驱动(FrameBuffer)实例开发讲解（一）.doc
06-12
嵌入式Linux之我行——S3C2440上LCD驱动(FrameBuffer)实例开发讲解（一）
[野火]《嵌入式Linux驱动开发实战指南——基于i.MX6ULL系列》
02-08
[野火]《嵌入式Linux驱动开发实战指南——基于i.MX6ULL系列》
嵌入式Linux之我行——内核通知链机制的原理及实现.pdf
09-14
嵌入式Linux之我行——内核通知链机制的原理及实现.pdf嵌入式Linux之我行——内核通知链机制的原理及实现.pdf
嵌入式Linux之我行系列
01-28
·嵌入式Linux之我行——按键驱动在2440上的实例开发（带去抖动） ·嵌入式Linux之我行——ARM MMU工作原理剖析 ·嵌入式Linux之我行——设备文件系统剖析与使用 ·嵌入式Linux之我行——PWM在ARM Linux中的原理和...
分行业城镇非私营单位就业人员平均实际工资指数(2004-2011年).xls
05-05
数据来源：中国劳动统计NJ-2023版
（更新至2022年）分行业城镇非私营单位就业人员年末人数.xls
05-05
数据来源：中国人口与就业统计NJ-2023版
Smart继电器编程器操作手册
05-04
Smart继电器编程器操作手册
node-v6.0.0.tar.xz
05-04
Node.js，简称Node，是一个开源且跨平台的JavaScript运行时环境，它允许在浏览器外运行JavaScript代码。Node.js于2009年由Ryan Dahl创立，旨在创建高性能的Web服务器和网络应用程序。它基于Google Chrome的V8 JavaScript引擎，可以在Windows、Linux、Unix、Mac OS X等操作系统上运行。 Node.js的特点之一是事件驱动和非阻塞I/O模型，这使得它非常适合处理大量并发连接，从而在构建实时应用程序如在线游戏、聊天应用以及实时通讯服务时表现卓越。此外，Node.js使用了模块化的架构，通过npm（Node package manager，Node包管理器）,社区成员可以共享和复用代码，极大地促进了Node.js生态系统的发展和扩张。 Node.js不仅用于服务器端开发。随着技术的发展，它也被用于构建工具链、开发桌面应用程序、物联网设备等。Node.js能够处理文件系统、操作数据库、处理网络请求等，因此，开发者可以用JavaScript编写全栈应用程序，这一点大大提高了开发效率和便捷性。 在实践中，许多大型企业和组织已经采用Node.js作为其Web应用程序的开发平台，如Netflix、PayPal和Walmart等。它们利用Node.js提高了应用性能，简化了开发流程，并且能更快地响应市场需求。
分地区按行业分城镇非私营单位就业人员数（2022年）.xls
最新发布
05-05
数据来源：中国人口与就业统计NJ-2023版
（更新至2022年）分城乡就业人员年末人数.xls
05-05
数据来源：中国人口与就业统计NJ-2023版
基于matlab实现的图像几何校正的程序，根据靶图将tiger图像从鱼眼形变恢复.rar
05-04
基于matlab实现的图像几何校正的程序，根据靶图将tiger图像从鱼眼形变恢复.rar
毕业论文（设计）—旅游资源管理系统设计与实现论文.doc
05-04
毕业论文（设计）—旅游资源管理系统设计与实现论文.doc
各地区其他单位分登记注册类型就业人员和工资总额(2022年).xls
05-05
数据来源：中国劳动统计NJ-2023版
嵌入式linux系统的开发——SDK环境的应用
06-08
在嵌入式Linux系统的开发中，使用SDK环境可以大大提高开发效率和软件质量。以下是一些常见的应用场景： 1. 交叉编译：在嵌入式系统中，通常使用交叉编译工具链来编译和构建应用程序。SDK环境中集成了交叉编译器，...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值