Linux 驱动开发 三十三：Linux 按键输入

最新推荐文章于 2024-09-25 17:07:44 发布
最新推荐文章于 2024-09-25 17:07:44 发布
阅读量1.9k 收藏 5
点赞数
分类专栏： Linux驱动开发 文章标签： linux
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/OnlyLove_/article/details/122227103
版权
本文详细介绍了如何在正点原子NPX开发板上进行按键驱动的设备树配置、驱动编写及测试。首先分析了按键的工作原理，接着修改设备树，将UART1_CTS引脚复用为GPIO并添加key设备节点。然后编译设备树并进行测试，确认设备树修改正确。接下来编写驱动程序，包括分配设备号、注册字符设备、创建类和设备。最后编写并测试应用程序，验证驱动功能。整个过程展示了从硬件到软件的完整实现流程。
摘要由CSDN通过智能技术生成

以正点原子 NPX 开发板进行实验。

一、原理分析

在这里插入图片描述
在这里插入图片描述
通过原理图分析可以得到，当按键按下后 KEY0 为低电平，当按键释放后 KEY0 为高电平。通过原理图可以确定 KEY0 连接在 UART1_CTS 引脚上。

二、修改设备树

1、查找引脚是否被使用

按键使用引脚如下：
在这里插入图片描述
从设备树中查找是否 UART1_CTS 引脚：
在这里插入图片描述
打开 imx6ull-lq-evk.dts，在 iomuxc 节点的 imx6ul-evk 子节点下创建一个名为 “pinctrl_key” 的子节点，节点 内容如下所示：

2、添加 pinctrl 节点

pinctrl_key: keygrp {
	fsl,pins = <
		MX6UL_PAD_UART1_CTS_B__GPIO1_IO18 0xF080
	>;
};

将引脚复用为 GPIO1_IO18，并将电气属性寄存器值设置为为 0xF080。

3、添加 key 设备节点

在根节点 “/” 下创建 key 节点，节点名为 “key”，节点内容如下：

lq-key {
	compatible = "lq-key";
	status = "okay";
	pinctrl-names = "default";
	pinctrl-0 = <&pinctrl_key>;
	key-gpio = <&gpio1 18 GPIO_ACTIVE_LOW>;
};

4、编译设备树

onlylove@ubuntu:~/linux/linux/lq_linux/linux-imx-rel_imx_4.1.15_2.1.0_ga$ make dtbs
  CHK     include/config/kernel.release
  CHK     include/generated/uapi/linux/version.h
  CHK     include/generated/utsrelease.h
make[1]: 'include/generated/mach-types.h' is up to date.
  CHK     include/generated/bounds.h
  CHK     include/generated/asm-offsets.h
  CALL    scripts/checksyscalls.sh
  DTC     arch/arm/boot/dts/imx6ull-lq-evk.dtb
onlylove@ubuntu:~/linux/linux/lq_linux/linux-imx-rel_imx_4.1.15_2.1.0_ga$

5、测试

/sys/firmware/devicetree/base # ls
#address-cells                 lq-led
#size-cells                    memory
aliases                        model
backlight                      name
chosen                         pxp_v4l2
clocks                         regulators
compatible                     reserved-memory
cpus                           soc
gpioled                        sound
interrupt-controller@00a01000  spi4
lq-key
/sys/firmware/devicetree/base # cd lq-key/
/sys/firmware/devicetree/base/lq-key # ls
compatible     name           pinctrl-names
key-gpio       pinctrl-0      status
/sys/firmware/devicetree/base/lq-key # ls
compatible     name           pinctrl-names
key-gpio       pinctrl-0      status
/sys/firmware/devicetree/base/lq-key # cat compatible
lq-key
/sys/firmware/devicetree/base/lq-key #

三、驱动编写

1、配置工程

在 VSCode 中添加 Linux 源码中的头文件路径。打开 VSCode，按下 “Crtl+Shift+P” 打开 VSCode 的控制台，然后输入 “C/C++: Edit configurations(JSON) ”，打开 C/C++ 编辑配置文件，添加 Linux 源码头文件路径，修改后内容如下：

{
    "configurations": [
        {
            "name": "Linux",
            "includePath": [
                "${workspaceFolder}/**",
                "/home/onlylove/linux/linux/lq_linux/linux-imx-rel_imx_4.1.15_2.1.0_ga/include",
                "/home/onlylove/linux/linux/lq_linux/linux-imx-rel_imx_4.1.15_2.1.0_ga/arch/arm/include",
                "/home/onlylove/linux/linux/lq_linux/linux-imx-rel_imx_4.1.15_2.1.0_ga/arch/arm/include/generated"
            ],
            "defines": [],
            "compilerPath": "/usr/bin/gcc",
            "cStandard": "gnu17",
            "cppStandard": "gnu++14",
            "intelliSenseMode": "linux-gcc-x64"
        }
    ],
    "version": 4
}

2、makefile

KERNELDIR := /home/onlylove/linux/linux/lq_linux/linux-imx-rel_imx_4.1.15_2.1.0_ga
CURRENT_PATH := $(shell pwd)
obj-m := key.o

build: kernel_modules

kernel_modules:
	$(MAKE) -C $(KERNELDIR) M=$(CURRENT_PATH) modules
clean:
	$(MAKE) -C $(KERNELDIR) M=$(CURRENT_PATH) clean

3、驱动框架编写和测试

源码如下：

#include "linux/init.h"
#include "linux/module.h"
#include "linux/fs.h"
#include "linux/cdev.h"
#include "linux/device.h"

#define KEYDEV_MAJOR 0  // 主设备号
#define KEYDEV_MINOR 0  // 次设备号
#define KEYDEV_CONUT 1  // 设备号个数
#define KEYDEV_NAME "keydev"    // 设备文件名

/* 驱动使用数据管理 */
typedef struct{
    int major;      // 主设备号
    int minor;      // 次设备号
    dev_t devid;    // 设备号
    struct cdev dev;
    struct class *class;
    struct device *device;
}keydev_t;

keydev_t keydev;

static const struct file_operations keydevops = {
    .owner   = THIS_MODULE,
};

/* 驱动加载函数 */
static int __init key_init(void)
{
    int ret = 0;
    /* 1、分配设备号 */
    keydev.major = KEYDEV_MAJOR;
    if(keydev.major){
        // 指定设备号
        keydev.minor = KEYDEV_MINOR;
        keydev.devid = MKDEV(keydev.major,keydev.minor);
        ret = register_chrdev_region(keydev.devid,KEYDEV_CONUT,KEYDEV_NAME);
    }else{
        // 分配设备号
        ret = alloc_chrdev_region(&keydev.devid,0,KEYDEV_CONUT,KEYDEV_NAME);
        keydev.major = MAJOR(keydev.devid);
        keydev.minor = MINOR(keydev.devid);
    }
    if(ret < 0){
        printk("keydev xxx_chrdev_region failed!\r\n");
        goto keydev_chrdev_region_failed;
    }
    printk("keydev major=%d,minor=%d\r\n",keydev.major,keydev.minor);
    
    /* 2、注册字符设备 */
    keydev.dev.owner = THIS_MODULE;
    cdev_init(&keydev.dev,&keydevops);
    ret = cdev_add(&keydev.dev,keydev.devid,KEYDEV_CONUT);
    if(ret < 0){
        printk("keydev cdev_add failed!\r\n");
        goto keydev_cdev_add_failed;
    }
    /* 3、创建类 */
    keydev.class = class_create(THIS_MODULE,KEYDEV_NAME);
    if (IS_ERR(keydev.class)) {
        printk("keydev class_create failed!\r\n");
        goto keydev_class_create_failed;
    }
    /* 4、创建设备 */
    keydev.device = device_create(keydev.class,NULL,keydev.devid,NULL,KEYDEV_NAME);
    if(IS_ERR(keydev.device)){
        printk("keydev device_create failed!\r\n");
        goto keydev_device_creat_failed;
    }

    return 0;
keydev_device_creat_failed:
    class_destroy(keydev.class);
keydev_class_create_failed:
    cdev_del(&keydev.dev);
keydev_cdev_add_failed:
    unregister_chrdev_region(keydev.devid,KEYDEV_CONUT);
keydev_chrdev_region_failed:
    return ret;
}

/* 驱动卸载函数 */
static void __exit key_exit(void)
{
    /* 4、删除设备 */
    device_destroy(keydev.class,keydev.devid);
    /* 3、删除类 */
    class_destroy(keydev.class);
    /* 2、注销字符设备 */
    cdev_del(&keydev.dev);
    /* 1、释放设备号 */
    unregister_chrdev_region(keydev.devid,KEYDEV_CONUT);
}

module_init(key_init);
module_exit(key_exit);

MODULE_LICENSE("GPL");

编译：

onlylove@ubuntu:~/linux/driver/linux_driver/6_key$ make
make -C /home/onlylove/linux/linux/lq_linux/linux-imx-rel_imx_4.1.15_2.1.0_ga M=/home/onlylove/linux/driver/linux_driver/6_key modules
make[1]: Entering directory '/home/onlylove/linux/linux/lq_linux/linux-imx-rel_imx_4.1.15_2.1.0_ga'
  CC [M]  /home/onlylove/linux/driver/linux_driver/6_key/key.o
  Building modules, stage 2.
  MODPOST 1 modules
  CC      /home/onlylove/linux/driver/linux_driver/6_key/key.mod.o
  LD [M]  /home/onlylove/linux/driver/linux_driver/6_key/key.ko
make[1]: Leaving directory '/home/onlylove/linux/linux/lq_linux/linux-imx-rel_imx_4.1.15_2.1.0_ga'
onlylove@ubuntu:~/linux/driver/linux_driver/6_key$

测试：

/ # ls
bin          gpio-led.ko  led_dts.ko   mnt          sbin         usr
dev          key.ko       lib          proc         sys
etc          led          linuxrc      root         tmp
/ # lsmod
Module                  Size  Used by    Tainted: G
/ # ls /dev/keydev -l
ls: /dev/keydev: No such file or directory
/ # 
/ # 
/ # insmod key.ko
keydev major=248,minor=0
/ # lsmod
Module                  Size  Used by    Tainted: G
key                     1299  0
/ # ls /dev/keydev -l
crw-rw----    1 0        0         248,   0 Jan  1 01:06 /dev/keydev
/ #
/ #
/ # rmmod key.ko
/ # lsmod key.ko
Module                  Size  Used by    Tainted: G
/ # ls /dev/keydev -l
ls: /dev/keydev: No such file or directory
/ #

4、key驱动完善

#include "linux/init.h"
#include "linux/module.h"
#include "linux/fs.h"
#include "linux/cdev.h"
#include "linux/device.h"
#include "linux/of.h"
#include "linux/of_gpio.h"
#include "linux/gpio.h"
#include "linux/atomic.h"
#include "asm/uaccess.h"

#define KEYDEV_MAJOR 0  // 主设备号
#define KEYDEV_MINOR 0  // 次设备号
#define KEYDEV_CONUT 1  // 设备号个数
#define KEYDEV_NAME "keydev"    // 设备文件名

#define KEY0VALUE   0XF0    /* 按键值 */
#define INVAKEY     0X00    /* 无效的按键值 */

/* 驱动使用数据管理 */
typedef struct{
    int major;      // 主设备号
    int minor;      // 次设备号
    dev_t devid;    // 设备号
    struct cdev dev;
    struct class *class;
    struct device *device;
    struct device_node *nd;
    int key_gpio;
    atomic_t keyvalue;
}keydev_t;

keydev_t keydev;

/* key 通过读取设备树 */
static int lq_key_init(void)
{
    keydev.nd = of_find_node_by_path("/lq-key");
    if(keydev.nd == NULL){
        return -EINVAL;
    }
    keydev.key_gpio = of_get_named_gpio(keydev.nd ,"key-gpio", 0);
    if(keydev.key_gpio < 0){
        printk("can't get key0\r\n");
        return -EINVAL;
    }
    printk("key_gpio=%d\r\n", keydev.key_gpio);

    gpio_request(keydev.key_gpio, "key0");  // 请求 IO
    gpio_direction_input(keydev.key_gpio);  // 设置为输入 

    return 0;
}

static int key_open(struct inode *inode, struct file *filp)
{
    int ret = 0;

    filp->private_data = &keydev; 
    ret = lq_key_init();
    if (ret < 0) {
        return ret;
    }

    return 0;
}

static ssize_t key_read(struct file *filp, char __user *buf, size_t cnt, loff_t *offt)
{
    int ret = 0;
    unsigned char value;
    keydev_t *dev = filp->private_data;

    if (gpio_get_value(dev->key_gpio) == 0) {
        while(!gpio_get_value(dev->key_gpio));
        atomic_set(&dev->keyvalue, KEY0VALUE);
    }else{
        atomic_set(&dev->keyvalue, INVAKEY);
    }
    value = atomic_read(&dev->keyvalue);
    ret = copy_to_user(buf, &value, sizeof(value));

    return ret;
}

static const struct file_operations keydevops = {
    .owner   = THIS_MODULE,
    .open = key_open,
    .read = key_read,
};

/* 驱动加载函数 */
static int __init key_init(void)
{
    int ret = 0;
    /* 1、分配设备号 */
    keydev.major = KEYDEV_MAJOR;
    if(keydev.major){
        // 指定设备号
        keydev.minor = KEYDEV_MINOR;
        keydev.devid = MKDEV(keydev.major,keydev.minor);
        ret = register_chrdev_region(keydev.devid,KEYDEV_CONUT,KEYDEV_NAME);
    }else{
        // 分配设备号
        ret = alloc_chrdev_region(&keydev.devid,0,KEYDEV_CONUT,KEYDEV_NAME);
        keydev.major = MAJOR(keydev.devid);
        keydev.minor = MINOR(keydev.devid);
    }
    if(ret < 0){
        printk("keydev xxx_chrdev_region failed!\r\n");
        goto keydev_chrdev_region_failed;
    }
    printk("keydev major=%d,minor=%d\r\n",keydev.major,keydev.minor);
    
    /* 2、注册字符设备 */
    keydev.dev.owner = THIS_MODULE;
    cdev_init(&keydev.dev,&keydevops);
    ret = cdev_add(&keydev.dev,keydev.devid,KEYDEV_CONUT);
    if(ret < 0){
        printk("keydev cdev_add failed!\r\n");
        goto keydev_cdev_add_failed;
    }
    /* 3、创建类 */
    keydev.class = class_create(THIS_MODULE,KEYDEV_NAME);
    if (IS_ERR(keydev.class)) {
        printk("keydev class_create failed!\r\n");
        goto keydev_class_create_failed;
    }
    /* 4、创建设备 */
    keydev.device = device_create(keydev.class,NULL,keydev.devid,NULL,KEYDEV_NAME);
    if(IS_ERR(keydev.device)){
        printk("keydev device_create failed!\r\n");
        goto keydev_device_creat_failed;
    }

    return 0;
keydev_device_creat_failed:
    class_destroy(keydev.class);
keydev_class_create_failed:
    cdev_del(&keydev.dev);
keydev_cdev_add_failed:
    unregister_chrdev_region(keydev.devid,KEYDEV_CONUT);
keydev_chrdev_region_failed:
    return ret;
}

/* 驱动卸载函数 */
static void __exit key_exit(void)
{
    /* 4、删除设备 */
    device_destroy(keydev.class,keydev.devid);
    /* 3、删除类 */
    class_destroy(keydev.class);
    /* 2、注销字符设备 */
    cdev_del(&keydev.dev);
    /* 1、释放设备号 */
    unregister_chrdev_region(keydev.devid,KEYDEV_CONUT);
}

module_init(key_init);
module_exit(key_exit);

MODULE_LICENSE("GPL");

四、应用程序编写

#include "stdio.h"
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>

#define KEY0VALUE   0XF0

int main(int argc, char *argv[])
{
    int fd, ret;
    char *filename;
    unsigned char keyvalue;

    filename = argv[1];

    fd = open(filename, O_RDWR);
    if(fd < 0){
        printf("file %s open failed!\r\n", argv[1]);
        return -1;
    }

    while(1){
        read(fd, &keyvalue, sizeof(keyvalue));
        if (keyvalue == KEY0VALUE){
            printf("KEY0 Press, value = %#X\r\n", keyvalue);
        }
    }


    return 0;
}

五、测试

/ # ls
bin      etc      key_app  linuxrc  proc     sbin     tmp
dev      key.ko   lib      mnt      root     sys      usr
/ #
/ # lsmod
Module                  Size  Used by    Not tainted
/ # ls -l /dev/keydev
ls: /dev/keydev: No such file or directory
/ #
/ # insmod key.ko
keydev major=248,minor=0
/ #
/ # lsmod
Module                  Size  Used by    Tainted: G
key                     1881  0
/ # ls -l /dev/keydev
crw-rw----    1 0        0         248,   0 Jan  1 01:59 /dev/keydev
/ #
/ # rmmod key.ko
/ #
/ # lsmod
Module                  Size  Used by    Tainted: G
/ # ls -l /dev/keydev
ls: /dev/keydev: No such file or directory
/ #
/ # insmod key.ko
keydev major=248,minor=0
/ #
/ # lsmod
Module                  Size  Used by    Tainted: G
key                     1881  0
/ # ls -l /dev/keydev
crw-rw----    1 0        0         248,   0 Jan  1 02:00 /dev/keydev
/ #
/ # ./key_app /dev/keydev
key_gpio=18
KEY0 Press, value = 0XF0
KEY0 Press, value = 0XF0
KEY0 Press, value = 0XF0
KEY0 Press, value = 0XF0
KEY0 Press, value = 0XF0
KEY0 Press, value = 0XF0
KEY0 Press, value = 0XF0
KEY0 Press, value = 0XF0
KEY0 Press, value = 0XF0
KEY0 Press, value = 0XF0
KEY0 Press, value = 0XF0
KEY0 Press, value = 0XF0
KEY0 Press, value = 0XF0
KEY0 Press, value = 0XF0
KEY0 Press, value = 0XF0
^C
/ #

通过以上日志可以确定，驱动可以正常运行。

六、说明

驱动仅仅为了测试功能，不够完善。在实际开发中也不会使用如此方法。在实际开发中会使用 Linux 中 input 子系统完成。

lqonlylove
关注
专栏目录
Linux 驱动开发 - 编写按键驱动
走向CTO的路上...
06-12 843
按键驱动程序是一种允许用户空间应用程序读取按键输入的 Linux 驱动程序。本指南介绍如何编写一个简单的按键驱动程序。本指南介绍了如何编写一个简单的按键驱动程序。通过遵循提供的算法和代码示例，开发人员可以创建驱动程序来读取按键输入并将其提供给用户空间应用程序。
Linux中的输入与输出
Sunrise的博客
11-08 4184
Linux中的输入与输出 .一、管理输入输出 在linux系统中，正确输出的编号为1，错误输出编号为2
Linux驱动_按键输入
qq_42174306的博客
03-22 317
一、修改设备树文件 (1)添加pinctrl节点 打开imx6ull-alientek-emmc.dts文件，在 iomuxc 节点的 imx6ul-evk 子节点下创建一个名为“pinctrl_key”的子节点，节点内容如下所示： ##该节点的作用是设置电气属性 (2)添加Key设备节点 在根节点“/”下创建 Key按键节点，节点内容如下： (3)启动系统 Linux系...
Linux驱动开发(速记版)--驱动基础
最新发布
荒野
09-25 1417
讯为开发板，RK3568
linux按键输入
weixin_44740398的博客
04-24 294
qt嵌入式开发，如何让程序响应外接按键，实现自定义键盘？ [问题点数：0分] https://bbs.csdn.net/topics/394462001 嵌入式linux上QT标准键盘输入的实现 https://www.oschina.net/question/565065_57628 ...
Linux 按键输入驱动
热门推荐
123
05-18 1万+
  按键驱动是操作 GPIO，在驱动程序中使用一个整形变量来表示按键值，应用程序通过 read 函数来读取按键值，判断按键有没有按下。 因为保存按键值的变量是个共享资源，驱动程序要向其写入按键值，应用程序要读取按键值。所以要对其进行保护，对于整形变量而言首选的是原子操作，使用原子操作对变量进行赋值以及读取。   读取按键一般采用中断的方式，并且采用定时器来实现按键消抖。此外在编写驱动的时候一定要考虑到阻塞和非阻塞的情况。对于按键输入驱动程序，最好的方式就是驱动程序能主动向应用程序发出通知，报告自己可以访问，
Linux 按键输入（和beep类似只是编程输入信号）
weixin_47295886的博客
04-27 465
1、在设备树中添加pinctrl和gpio子系统的设备节点 在&iomuxc 中添加pinctrl信息 pincrtl_key: keygrp{ fsl,pins = < /*beep的外设电气属性 加 寄存器地址 MX6UL_PAD_UART1_CTS_B__GPIO1_IO18*/ /*MX6UL_PAD_UART1_CTS_B__GPIO1_IO18 0x008C 0x0318 0x00...
嵌入式Linux按键驱动程序开发.pdf
09-06
嵌入式 Linux 按键驱动程序开发 本文主要介绍了 Linux 驱动程序的基本概念、字符设备、块设备和网络设备的特点，并通过键盘驱动实例讲述了如何设计和编写模块化的驱动程序，并解释了键盘驱动程序的关键代码。最后，...
key__test.rar_linux 按键驱动 _嵌入式linux 驱动_按键 驱动_按键驱动_驱动 测试
09-23
本文将深入探讨“key__test.rar_linux按键驱动”这一主题，包括按键驱动的基本概念、工作原理以及如何在嵌入式环境中进行驱动开发和测试。 一、按键驱动概述 按键驱动是嵌入式Linux系统中的一个关键组件，它负责...
嵌入式Linux按键驱动，支持短按和长按检测
03-15
在嵌入式Linux系统中，按键驱动是与用户交互的重要组成部分。...通过阅读和理解这些代码，开发者可以学习到如何构建一个完整的嵌入式Linux按键驱动，同时掌握平台驱动框架、中断处理、定时器和非阻塞IO的相关知识。
linux按键驱动 轮询input上报可做linux 矩阵键盘的按键驱动
02-01
linux按键驱动 轮询input上报可做linux 矩阵键盘的按键驱动，通过input子系统上报，devinputeventx 接收事件可用于指定QT产生类似键盘的输入事件.zip
Linux学习 按键输入
i阳光仔的博客
12-19 273
文章目录1.原理图 1.原理图 可以看出，按键 KEY0 是连接到 I.MX6U 的 UART1_CTS 这个 IO 上的，KEY0接了一个 10K 的上拉电阻，因此 KEY0 没有按下的时候 UART1_CTS 应该是高电平，当 KEY0按下以后 UART1_CTS 就是低电平 2.BSP_GPIO.H #ifndef _BSP_GPIO_H #define _BSP_GPIO_H #define _BSP_KEY_H #include "imx6ul.h" /*********************
linux：输入/输出、重定向、管道
青鬆下的ミ坚躯 的个人博客
04-09 2114
输入、输出：     程序的默认输入设备，叫标准输入。 stdin    键盘   0     程序的默认输出设备，叫标准输出。 stdout    监视器    1     程序的默认错误输出设备，叫标准错误输出。stderr    监视器  2 输出重定向 >、>>、>|：     把输入内容输出到其他地方。     >：COMMOND > FILE 覆盖重定向        
linux驱动之按键输入实验（基于系统自带gpio-keys.c驱动）
fengweibo112的博客
10-28 4804
概述 采用Linux自带的按键驱动gpio-keys.c，实现按键输入读取。与上一章实现led-gpio类似。 修改设备树文件 在根节点‘/’下创建key节点，节点名称为keys。节点内容如下（可参考别的平台的key节点编写）： keys: { compatible = “gpio-keys”; key1{ label = “volume-up” linux,code = <114>;...
Linux按键输入实验(体验一下输入驱动，实际开发使用input子系统处理)
zhuguanlin121的博客
11-08 1070
目录Linux 下按键驱动原理49.2 硬件原理图分析49.3 实验程序编写49.3.1 修改设备树文件按键驱动程序编写编写测试APP运行测试编译驱动程序和测试APP运行测试 在前几章我们都是使用的GPIO 输出功能，还没有用过GPIO 输入功能，本章我们就来学习一下如果在Linux 下编写GPIO 输入驱动程序。I.MX6U-ALPHA 开发板上有一个按键，我们就使用此按键来完成GPIO 输入驱动程序，同时利用第四十七章讲的原子操作来对按键值进行保护。 Linux 下按键驱动原理 按键驱动和LED 驱动原
linux 输入输出管理
L*YUE的博客
01-05 428
目录输入输出的定义两种输出方式管道 输入输出的定义 1.Stdin[标准输入流] 输入是指系统外接向系统中传递的信息 2.stdout[标准正确输出] 在命令顺利执行完成后产生的字符串 ，stdout在Linux中的输出编号为1 3.stderr[标准错误输出] 在命令失败执行完成后产生的字符串 ， stderr在Linux中的输出编号为2 两种输出方式 1.重定向输出 重定向是指将原本要输出到屏...
Linux输入系统
启程
01-05 1444
输入系统简介： 内核对多种不同类别的输入设备(如键盘，鼠标，跟踪球，操纵杆，触摸屏，加速计和手写板等)在字符设备驱动 上进行了统一的抽象。输入子系统包括两类驱动程序：事件驱动程序(对应系统中的各种handler)和设备驱动程序。事件驱动程序负责和应用程序的接口，而设备驱动程序负责和底层输入设备的通信。列如鼠标事件生成文件mousedev.c属于事件驱动程序，而kernel/dr
08_Linux按键输入
Yuanghxb的博客
07-02 581
第56-74行,函数keyio_init用于初始化按键,从设备树中获取按键的gpio信息,然后设置为输入。第36-46行,结构体key_dev为按键的设备结构体,第45行的原子变量keyvalue用于记录按键值。第104-120行, keyread函数,应用程序通过read函数读取按键值的时候此函数就会执行。第83-94行, key_open函数通过调用keyio_init函数来始化按键所使用的。按键释放以后标记按键值为KEYOVALUE。O,应用程序每次打开按键驱动文件的时候都会初始化一次按键IO。
linux--处理用户输入
wujingjing_crystal的专栏
08-21 752
有时我们需要写个和运行脚本的人交互的脚本。bash shell提供了一些不同的方法来从用户处获得数据，包括命令行参数（添加在命令后的数据值）、命令行选项（可修改命令行为的单字母值）以及直接从键盘读取输入的能力。一、命令行参数向shell脚本传数据的最基本方法是使用命令行参数。命令行参数允许在运行脚本时向命令行添加数据值：$ ./addem 10 30 #向脚本addem传递了两个命令行参数1.1 读
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值