输入系统应用编程--APP访问硬件编程

最新推荐文章于 2024-07-30 19:53:12 发布
最新推荐文章于 2024-07-30 19:53:12 发布
阅读量534 收藏 5
点赞数 1
分类专栏： imx6ull linux 文章标签： linux imx6ull
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_49001854/article/details/120600839
版权

一、输入系统框架

在这里插入图片描述

假设用户程序直接访问/dev/input/event0设备节点，或者使用tslib访问设备节点，数据的流程如下：

  • APP发起读操作，若无数据则休眠；
  • 用户操作设备，硬件上产生中断；
  • 输入系统驱动层对应的驱动程序处理中断：
    读取到数据，转换为标准的输入事件，向核心层汇报。
    所谓输入事件就是一个“struct input_event”结构体。
  • 核心层可以决定把输入事件转发给上面哪个handler来处理：
    从handler的名字来看，它就是用来处输入操作的。有多种handler，比如：evdev_handler、kbd_handler、joydev_handler等等。
    最常用的是evdev_handler：它只是把input_event结构体保存在内核buffer等，APP来读取时就原原本本地返回。它支持多个APP同时访问输入设备，每个APP都可以获得同一份输入事件。
    当APP正在等待数据时，evdev_handler会把它唤醒，这样APP就可以返回数据。
  • APP对输入事件的处理：
    APP获得数据的方法有2种：直接访问设备节点(比如/dev/input/event0,1,2,…)，或者通过tslib、libinput这类库来间接访问设备节点。这些库简化了对数据的处理。

APP得到的输入事件

输入事件结构体

struct input_event {
	struct timeval time;  // 发生的时间
	__u16 type;				// 哪类事件
	__u16 code;			// 哪个事件
	__s32 value;			// 事件值
};

事件类型：type
EV_KEY表示按键类、EV_REL表示相对位移(比如鼠标)，EV_ABS表示绝对位置(比如触摸屏)

/*
 * Event types
 */

#define EV_SYN			0x00   // 同步事件
#define EV_KEY			0x01
#define EV_REL			0x02
#define EV_ABS			0x03
#define EV_MSC			0x04
#define EV_SW			0x05
#define EV_LED			0x11
#define EV_SND			0x12
#define EV_REP			0x14
#define EV_FF			0x15
#define EV_PWR			0x16
#define EV_FF_STATUS		0x17
#define EV_MAX			0x1f
#define EV_CNT			(EV_MAX+1)

哪个具体事件：code
对于EV_KEY(按键)类事件，它表示键盘。键盘上有很多按键，比如数字键1、2、3，字母键A、B、C里等。

#define KEY_RESERVED		0
#define KEY_ESC			1
#define KEY_1			2
#define KEY_2			3
#define KEY_3			4
#define KEY_4			5
#define KEY_5			6
#define KEY_6			7
#define KEY_7			8

对于触摸屏，它提供的是绝对位置信息，有X方向、Y方向，还有压力值。所以code值有这些：

#define ABS_X			0x00
#define ABS_Y			0x01
#define ABS_Z			0x02
...........

事件值:value
对于按键，它的value可以是0(表示按键被松开)、1(表示按键被按下)、2(表示长按)；
对于触摸屏，它的value就是坐标值、压力值。

若驱动程序上报完所有数据后，会上报一个同步事件表示数据上报完毕。
同步事件的type、code、value都是0

内核中表示的输入设备

struct input_dev {
	const char *name;
	const char *phys;
	const char *uniq;
	struct input_id id;

	unsigned long propbit[BITS_TO_LONGS(INPUT_PROP_CNT)];
	
	// 支持哪类事件，支持哪些
	unsigned long evbit[BITS_TO_LONGS(EV_CNT)];
	unsigned long keybit[BITS_TO_LONGS(KEY_CNT)];
	unsigned long relbit[BITS_TO_LONGS(REL_CNT)];
	unsigned long absbit[BITS_TO_LONGS(ABS_CNT)];
	unsigned long mscbit[BITS_TO_LONGS(MSC_CNT)];
	unsigned long ledbit[BITS_TO_LONGS(LED_CNT)];
	unsigned long sndbit[BITS_TO_LONGS(SND_CNT)];
	unsigned long ffbit[BITS_TO_LONGS(FF_CNT)];
	unsigned long swbit[BITS_TO_LONGS(SW_CNT)];
	..............................
}

二、常用命令

  • 查看设备节点：ls /dev/input/* -l
  • 查看设备节点对应硬件信息：cat /proc/bus/input/devices
    信息对应内核中表示的输入设备信息
    在这里插入图片描述
    上图中“B: EV=b”用来表示该设备支持哪类输入事件。b的二进制是1011，bit0、1、3为1，表示该设备支持0、1、3这三类事件，即EV_SYN、EV_KEY、EV_ABS。
  • 使用命令读取数据：hexdump /dev/input/event1（我这里event1表示触摸屏）
    在开发板上执行读取屏幕数据命令后，先会阻塞，点击或滑动触摸屏后，会打印信息。

三、获取输入设备信息

在这里插入图片描述
要想打印出struct input_id 中的数据即硬件本身信息，根据linux源码中evdev.c文件中相关函数，可知ioctl的request要写为EVIOCGID。
在这里插入图片描述
要想获取硬件支持哪类事件（如相对位移事件，绝对位移事件），就要读取输入设备的evbit，ioctl的request要写为“EVIOCGBIT(0, size)”，size的大小可以由你决定：你想读多少字节就设置为多少。

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

/*获取输入设备信息*/
/* ./get_input_info /dev/input/event0 */
int main(int argc,char **argv)
{   
    struct input_id id;
    int fd;
    int err;
    int len;
    int i;
    int bit;
    unsigned int evbit[2];
    unsigned char byte;
	
	// 支持事件的类型
    char *ev_names[] = {
        "EV_SYN",			
        "EV_KEY",			
        "EV_REL",			
        "EV_ABS",			
        "EV_MSC",			
        "EV_SW",			
        "NULL",
        "NULL",
        "NULL",
        "NULL",
        "NULL",
        "NULL",
        "NULL",
        "NULL",
        "NULL",
        "NULL",
        "NULL",
        "NULL",
        "EV_LED",			
        "EV_SND",			
        "NULL",
        "EV_REP",			
        "EV_FF",			
        "EV_PWR"				
  
    };
    
    if(argc!=2){
        printf("Usage:%s <dev>\n",argv[1]);
        return -1;
    }

    fd = open(argv[1],O_RDWR);
    if(fd==-1){
        printf("open error\n");
        return -1;
    }

    err = ioctl(fd,EVIOCGID,&id);
    if(err==0){
        printf("bustype is 0x%x\n",id.bustype);
        printf("vendor is 0x%x\n" ,id.vendor);
        printf("product is 0x%x\n",id.product);
        printf("version is 0x%x\n",id.version);
    }

    len = ioctl(fd,EVIOCGBIT(0, sizeof(evbit)),&evbit);
    if(len>0 && len<=sizeof(evbit)){
        printf("support ev type:");
        
        for(i=0;i<len;i++){
            byte = ((unsigned char*)evbit)[i];
            
            for(bit=0;bit<8;bit++){
                if(byte & (1<<bit)){
                    printf("%s ",ev_names[i*8+bit]);
                }
            }
        }
        printf("\n");
    }
    return 0;
}

在这里插入图片描述

四、APP访问硬件的四种方式

  • 查询方式
  • 休眠-唤醒
  • POLL和select方式
  • 异步通知

在上面获取输入设备的代码基础上实现完成APP访问硬件的编程

1.查询方式和休眠-唤醒方式

1.1介绍

查询方式：应用程序不停地去读取硬件信息，即使没有硬件信息发生
反映到程序上就是用open函数以不阻塞的方式打开设备，触摸屏没有发生事件，打印err,触摸屏发生滑动或点击等事件就打印相应信息。

休眠-唤醒方式：当发生硬件信息，应用程序才会访问硬件
反映到程序上就是用open函数以阻塞的方式（默认方式）打开设备。

1.2代码

#include <stdio.h>
#include <linux/input.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <string.h>
#include <unistd.h>

/*获取输入设备信息*/
/*查询方式 休眠-唤醒方式*/
/* ./get_input_info /dev/input/event1 noblock*/
int main(int argc,char **argv)
{   
    struct input_id id;
    int fd;
    int err;
    int len;
    int i;
    int bit;
    unsigned int evbit[2];
    unsigned char byte;

    struct input_event event;
    
    char *ev_names[] = {
        "EV_SYN",			
        "EV_KEY",			
        "EV_REL",			
        "EV_ABS",			
        "EV_MSC",			
        "EV_SW",			
        "NULL",
        "NULL",
        "NULL",
        "NULL",
        "NULL",
        "NULL",
        "NULL",
        "NULL",
        "NULL",
        "NULL",
        "NULL",
        "NULL",
        "EV_LED",			
        "EV_SND",			
        "NULL",
        "EV_REP",			
        "EV_FF",			
        "EV_PWR"				
  
    };
    
    if(argc<2){
        printf("Usage:%s <dev> [noblock]\n",argv[0]);
        return -1;
    }

    if(argc == 3 && !strcmp(argv[2],"noblock")){
        fd = open(argv[1],O_RDWR|O_NONBLOCK);
    }else{
        fd = open(argv[1],O_RDWR);
    }
    
    if(fd==-1){
        printf("open error\n");
        return -1;
    }

    err = ioctl(fd,EVIOCGID,&id);
    if(err==0){
        printf("bustype is 0x%x\n",id.bustype);
        printf("vendor is 0x%x\n" ,id.vendor);
        printf("product is 0x%x\n",id.product);
        printf("version is 0x%x\n",id.version);
    }

    len = ioctl(fd,EVIOCGBIT(0, sizeof(evbit)),&evbit);
    if(len>0 && len<=sizeof(evbit)){
        printf("support ev type:");
        
        for(i=0;i<len;i++){
            byte = ((unsigned char*)evbit)[i];
            
            for(bit=0;bit<8;bit++){
                if(byte & (1<<bit)){
                    printf("%s ",ev_names[i*8+bit]);
                }
            }
        }
        printf("\n");
    }

    while(1)
    {
        len = read(fd,&event,sizeof(event));
        if(len == sizeof(event)){
            printf("get event: type = 0x%x, code = 0x%x, value = 0x%x\n", event.type, event.code, event.value);	 
        }else{
            sleep(3);
            printf("err\n");
        }
    }
    return 0;
}


// 查询方式
./get_input_info     /dev/input/event1    noblock
//	休眠-唤醒方式
./get_input_info     /dev/input/event1

2.POLL方式及select方式

2.1 说明

APP不是直接调用read函数，而是先调用poll或select函数，这2个函数中可以传入“超时时间”。它们的作用是：如果驱动程序中有数据，则立刻返回；否则就休眠。在休眠期间，如果有人操作了硬件，驱动程序获得数据后就会把APP唤醒，导致poll或select立刻返回；如果在“超时时间”内无人操作硬件，则时间到后poll或select函数也会返回

poll/select函数可以监测多个文件，可以监测多种事件：

事件类型说明
POLLIN有数据可读
POLLRDNORM等同于POLLIN
POLLRDBANDPriority band data can be read，有优先级较较高的“band data”可读
POLLPRI高优先级数据可读
POLLOUT可以写数据
POLLWRNORM等同于POLLOUT
POLLWRBANDPriority data may be written
POLLERR发生了错误
POLLHUP挂起
POLLNVAL无效的请求，一般是fd未open

2.2 poll函数

#include <poll.h>

int poll(struct pollfd fds[], nfds_t nfds, int timeout)；
nfds：nfds_t类型的参数，用于标记数组fds中的结构体元素的总数量；
timeout：是poll函数调用阻塞的时间，单位：毫秒；
返回值为0表示超时
struct pollfd {
int fd; /文件描述符/
short events; /* 等待的需要测试事件 /
short revents; / 实际发生了的事件，也就是返回结果 */
};

2.3 poll方式代码

#include <stdio.h>
#include <linux/input.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <string.h>
#include <unistd.h>
#include <poll.h>

/*poll方式*/
/* ./input_read_poll /dev/input/event0 */
int main(int argc,char **argv)
{   
    struct input_id id;
    int fd;
    int err;
    int len;
    int i;
    int bit;
    int ret;
    nfds_t nfds = 1;
    unsigned int evbit[2];
    unsigned char byte;

    struct input_event event;
    struct pollfd fds[1];
    
    char *ev_names[] = {
        "EV_SYN",			
        "EV_KEY",			
        "EV_REL",			
        "EV_ABS",			
        "EV_MSC",			
        "EV_SW",			
        "NULL",
        "NULL",
        "NULL",
        "NULL",
        "NULL",
        "NULL",
        "NULL",
        "NULL",
        "NULL",
        "NULL",
        "NULL",
        "NULL",
        "EV_LED",			
        "EV_SND",			
        "NULL",
        "EV_REP",			
        "EV_FF",			
        "EV_PWR"				
  
    };
    
    if(argc!=2){
        printf("Usage:%s <dev>\n",argv[0]);
        return -1;
    }

    fd = open(argv[1],O_RDWR|O_NONBLOCK);
    
    if(fd==-1){
        printf("open error\n");
        return -1;
    }

    err = ioctl(fd,EVIOCGID,&id);
    if(err==0){
        printf("bustype is 0x%x\n",id.bustype);
        printf("vendor is 0x%x\n" ,id.vendor);
        printf("product is 0x%x\n",id.product);
        printf("version is 0x%x\n",id.version);
    }

    len = ioctl(fd,EVIOCGBIT(0, sizeof(evbit)),&evbit);
    if(len>0 && len<=sizeof(evbit)){
        printf("support ev type:");
        
        for(i=0;i<len;i++){
            byte = ((unsigned char*)evbit)[i];
            
            for(bit=0;bit<8;bit++){
                if(byte & (1<<bit)){
                    printf("%s ",ev_names[i*8+bit]);
                }
            }
        }
        printf("\n");
    }

    while(1)
    {   
        fds[0].fd = fd;
        // 监测的文件事件是数据可读
        fds[0].events = POLLIN;
        fds[0].revents = 0;

        ret = poll(fds,nfds,5000);
        if(ret>0)
       {
            
            if(fds[0].revents == POLLIN)
            {
                
                while(read(fd,&event,sizeof(event))==sizeof(event))
                {
                    printf("get event: type = 0x%x, code = 0x%x, value = 0x%x\n", event.type, event.code, event.value);
                }
            }           
        }
        else if(ret==0)
        {
            printf("time out\n");
        }
        else
        {
            printf("poll err\n");
        }
        
    }
    return 0;
}

2.4 select说明

select 方式
POLL机制、SELECT机制是完全一样的，只是APP接口函数不一样

int select(nfds, readfds, writefds, exceptfds, timeout)
nfds：select监视的文件句柄数，视进程中打开的文件数而定,一般设为你要监视各文件中的最大文件号加一。
readfds：select监视的可读文件句柄集合。
writefds: select监视的可写文件句柄集合。
exceptfds：select监视的异常文件句柄集合。
timeout：本次select()的超时结束时间
FD_ZERO(fd_set *fdset)：清空fdset与所有文件句柄的联系。
FD_SET(int fd, fd_set *fdset)：建立文件句柄fd与fdset的联系。
FD_CLR(int fd, fd_set *fdset)：清除文件句柄fd与fdset的联系。
FD_ISSET(int fd, fd_set *fdset)：检查fdset联系的文件句柄fd是否
可读写，当>0表示可读写。

2.4 select方式代码

#include <stdio.h>
#include <linux/input.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <string.h>
#include <unistd.h>
#include <sys/select.h>


/*select方式*/
/* ./input_read_select /dev/input/event0 */
int main(int argc,char **argv)
{   
    struct input_id id;
    int fd;
    int err;
    int len;
    int i;
    int bit;
    int ret;
    // 最大的文件句柄数+1
    int nfds = fd+1;
    fd_set readfds[1] = {fd};
   
    unsigned int evbit[2];
    unsigned char byte;

    struct input_event event;
    struct timeval time;
    
    char *ev_names[] = {
        "EV_SYN",			
        "EV_KEY",			
        "EV_REL",			
        "EV_ABS",			
        "EV_MSC",			
        "EV_SW",			
        "NULL",
        "NULL",
        "NULL",
        "NULL",
        "NULL",
        "NULL",
        "NULL",
        "NULL",
        "NULL",
        "NULL",
        "NULL",
        "NULL",
        "EV_LED",			
        "EV_SND",			
        "NULL",
        "EV_REP",			
        "EV_FF",			
        "EV_PWR"				
  
    };
    
    if(argc!=2){
        printf("Usage:%s <dev>\n",argv[0]);
        return -1;
    }

    fd = open(argv[1],O_RDWR|O_NONBLOCK);
    
    if(fd==-1){
        printf("open error\n");
        return -1;
    }

    err = ioctl(fd,EVIOCGID,&id);
    if(err==0){
        printf("bustype is 0x%x\n",id.bustype);
        printf("vendor is 0x%x\n" ,id.vendor);
        printf("product is 0x%x\n",id.product);
        printf("version is 0x%x\n",id.version);
    }

    len = ioctl(fd,EVIOCGBIT(0, sizeof(evbit)),&evbit);
    if(len>0 && len<=sizeof(evbit)){
        printf("support ev type:");
        
        for(i=0;i<len;i++){
            byte = ((unsigned char*)evbit)[i];
            
            for(bit=0;bit<8;bit++){
                if(byte & (1<<bit)){
                    printf("%s ",ev_names[i*8+bit]);
                }
            }
        }
        printf("\n");
    }

    while(1)
    {   
        // 清零
        FD_ZERO(readfds);
        // 建立文件句柄fd与readfds的联系
        FD_SET(fd, readfds);

        // 设置超时时间
        time.tv_sec = 5;
        time.tv_usec = 0;
        
        ret = select(nfds,readfds,NULL,NULL,&time);
        if(ret>0)
       {
            //再次确认fd有数据
            if(FD_ISSET(fd, readfds))
            {
                memset(&event,0,sizeof(event));
                while(read(fd,&event,sizeof(event))==sizeof(event))
                {
                    printf("get event: type = 0x%x, code = 0x%x, value = 0x%x\n", event.type, event.code, event.value);
                }
            }           
        }
        else if(ret==0)
        {
            printf("time out\n");
        }
        else
        {
            printf("select err\n");
        }
        
    }
    return 0;
}

3.异步通信方式

3.1 说明

异步通知，就是APP可以忙自己的事，当驱动程序用数据时它会主动给APP发信号，这会导致APP执行信号处理函数。

驱动程序通知APP时，它会发出“SIGIO”这个信号，表示有“IO事件”要处理。
就APP而言，你想处理SIGIO信息，那么需要提供信号处理函数，并且要跟SIGIO挂钩。这可以通过一个signal函数来“给某个信号注册处理函数”

linux信号具体介绍可参照这里

#include <signal.h>
typedef void (*sighandler_t)(int);
 sighandler_t signal(int signum, sighandler_t handler);

在编程时需要注意以下几点：

  • 内核里有那么多驱动，你想让哪一个驱动给你发SIGIO信号？
    APP要打开驱动程序的设备节点。
  • 驱动程序怎么知道要发信号给你而不是别人？
    APP要把自己的进程ID告诉驱动程序。
  • APP有时候想收到信号，有时候又不想收到信号：
    应该可以把APP的意愿告诉驱动：设置Flag里面的FASYNC位为1，使能“异步通知”。

linux fcntl函数详解可参照这里

3.2 代码

#include <stdio.h>
#include <linux/input.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <string.h>
#include <unistd.h>
#include <signal.h>

int fd;

void sig_hanler()
{   
    struct input_event event;

    memset(&event,0,sizeof(event));
    while(read(fd,&event,sizeof(event))==sizeof(event))
    {
        printf("get event: type = 0x%x, code = 0x%x, value = 0x%x\n", event.type, event.code, event.value);
    }
}

/*异步通信*/
/* ./input_read_fasync /dev/input/event1 */
int main(int argc,char **argv)
{   
    struct input_id id;
    int err;
    int len;
    int i;
    int bit;
    int count = 1;
    int flags;
    unsigned int evbit[2];
    unsigned char byte;
    
    char *ev_names[] = {
        "EV_SYN",			
        "EV_KEY",			
        "EV_REL",			
        "EV_ABS",			
        "EV_MSC",			
        "EV_SW",			
        "NULL",
        "NULL",
        "NULL",
        "NULL",
        "NULL",
        "NULL",
        "NULL",
        "NULL",
        "NULL",
        "NULL",
        "NULL",
        "NULL",
        "EV_LED",			
        "EV_SND",			
        "NULL",
        "EV_REP",			
        "EV_FF",			
        "EV_PWR"				
  
    };
    
    if(argc!=2)
    {
        printf("Usage:%s <dev>\n",argv[0]);
        return -1;
    }

    fd = open(argv[1],O_RDWR|O_NONBLOCK);
    
    if(fd==-1)
    {
        printf("open error\n");
        return -1;
    }

    err = ioctl(fd,EVIOCGID,&id);
    if(err==0)
    {
        printf("bustype is 0x%x\n",id.bustype);
        printf("vendor is 0x%x\n" ,id.vendor);
        printf("product is 0x%x\n",id.product);
        printf("version is 0x%x\n",id.version);
    }

    len = ioctl(fd,EVIOCGBIT(0, sizeof(evbit)),&evbit);
    if(len>0 && len<=sizeof(evbit))
    {
        printf("support ev type:");
        
        for(i=0;i<len;i++)
        {
            byte = ((unsigned char*)evbit)[i];
            
            for(bit=0;bit<8;bit++)
            {
                if(byte & (1<<bit))
                {
                    printf("%s ",ev_names[i*8+bit]);
                }
            }
        }
        printf("\n");
    }

    signal(SIGIO,sig_hanler);

    // 把进程ID告诉驱动
    fcntl(fd,F_SETOWN,getpid());

    // 使能驱动FASYNC
    flags = fcntl(fd, F_GETFL);
    fcntl(fd, F_SETFL, flags | FASYNC);

    while(1)
    {   
        sleep(3);
        printf("main loop:%d\n",count);
        count++;
    }
    
    return 0;
}
Heavy sea
关注
专栏目录
android app 访问framework硬件服务
云行雨施 品物流形
10-14 1314
二. 为了方便开发，我们可以在IDE环境下使用Android SDK来开发Android应用程序。开发完成后，再把程序源代码移植到Android源代码工程目录中。使用Eclipse的Android插件ADT创建Android工程很方便，这里不述，可以参考网上其它资料。工程名称为Hello，下面主例出主要文件：     主程序是src/shy/luo/hello/Hello.java：
用户访一个APP或者网页流程示意图
weixin_33877092的博客
02-09 337
用户访问示意图： 转载于:https://www.cnblogs.com/qfdxxdr/p/6380965.html
输入系统应用编程
最新发布
weixin_62822414的博客
07-30 769
此文章旨在对输入系统应用编程进行应用的学习以及相关API的操作，所学均来自百问网
应用程序直接访问硬件
weixin_34185364的博客
11-27 289
linux下，所有地址均为虚拟地址，需要由物理地址映射（ioremap或mmap）。//***************************************************************************************************#include &lt;stdio.h&gt;#include &lt;sys/mman.h&gt;#inclu...
输入设备框架1—应用层—完整的代码工程
欧阳海宾
08-26 1156
输入设备框架 应用层输入设备框架的头文件在#vi /usr/include/linux/input.h     type:是事件类型，都在这个头文件里有描述 如EV_KEY按键事件类型 type: 设备类型。可以设置为： #defineEV_SYN         0x00    表示设备支持所有的事件 #defineEV_KEY
06.输入系统：第10课第14节_输入系统_APP获得并处理输入事件流程
江南才尽江南山，年少无知年少狂！
03-13 400
从之前小节我们知道Dispatcher线程是如何分发事件给APP的，该小节我们讲解APP如何获取，并且处理这些输入事件。在前面的小节中，提到APP在得到一个fd之后，会把他封装成一个InputChannel，然后再封装成windowInputEvenReceiver，最终把fd注册到Looper中，使用epoll进行查询等待，该小节我们详细的分析fd注册到Looper的过程，APP调用总的详细框图.........
Speck-Chrome-App:CreateLab Speck 的 Chrome 应用程序
06-26
在Chrome应用中，JavaScript不仅可以用于操控DOM元素，还能利用Chrome API来访问浏览器的特有功能，如本地存储、通知系统、甚至硬件设备的访问权限。 在“Speck-Chrome-App-master”这个压缩包中，我们可以推测它...
chrome-note-app:chrome原生笔记应用
05-15
考虑到是Chrome原生应用，开发者可能使用了Chrome的特定API，如Chrome Apps API，来获取更多的系统级权限，如本地文件系统访问、硬件设备控制等。这些API让Chrome应用可以拥有比传统Web应用更丰富的功能和更接近桌面...
HC-05蓝牙模块_手机APP控制
01-24
HAL库是STMicroelectronics提供的，旨在简化微控制器的编程，提供了一套标准的API（应用程序接口）来访问底层硬件资源。例如，`HAL_UART_Transmit`函数用于发送数据到UART接口，`HAL_UART_Receive`函数则用于接收...
2021年全国计算机设计大赛软件服务外包企业命题-移动终端应用-停车宝app.pdf
06-03
"停车宝app"是一款针对移动终端应用的软件项目，旨在解决城市停车难的问题，通过集成大数据分析、电子商务、人机交互应用以及物联网技术，构建一个高效、智能的城市停车管理系统。这款应用参加了2021年全国计算机...
rn-colab-app:只是一个用于创建React-Native应用并帮助朋友学习新语言的小应用
03-28
rn-colab-app是一个小型项目，旨在利用React-Native框架帮助开发者和学习者构建移动应用程序，同时提供一个互动的平台来熟悉JavaScript编程语言。React-Native是Facebook开发的一个开源框架，它允许开发者使用...
应用程序是如何去访问所需的硬件资源的？
weixin_33928467的博客
07-19 764
应用程序是如何去访问所需的硬件资源的？今天我们来聊聊这个话题！大家都知道应用程序需要访问数据或者运行的时候都是通过CPU去访问内存地址空间，应用程序的数据通过存储在内存空间中以便于CPU进行快速的读写，CPU不会去硬盘读取数据也不会去U盘读取数据。那么当我们的应用程序需要访问硬件的时候，是怎么去访问的呢？在X86的体系架构的当中，存在着IO空间这样一个概念。...
04使用程序模拟键盘输入
12-14 496
void CSimulateKeyDlg::OnInput() { // TODO: Add your control notification handler code here static BOOL bChangeFlag=TRUE; if(bChangeFlag) { SetTimer(1,500,NULL);//设置定时器 bChangeFlag =bChangeFla
软件访问硬件的几种方式
poocher的博客
04-12 1102
学习于CodeSheep分享笔记。 软件访问硬件就是一种I/O操作。 直接访问 用户进程直接控制主存或CPU和外围设备之间的信息传递。又称为忙/等待方式。 中断驱动 为了减少直接访问方式下CPU的等待时间，同时提高系统的并行能力，系统引入中断机制。当外围设备正常操作结束或异常结束时向CPU发出中断请求。在 I/O 设备输入每个数据的过程中，由于无需 CPU 的干预，一定程度上实现了 CPU 与 I/O 设备的并行工作。 DMA直接内存访问 为了进一步减少 CPU 对 I/O 操作的干预，防止因
为Android编码小部件：输入和显示
代码教主
06-18 523
从Android 1.5开始，应用程序小部件使用户能够在舒适的主屏幕上获取信息，控制应用程序并执行关键任务。 在这个由两部分组成的系列文章中，我将向您展示如何通过向Android项目中添加应用程序小部件来提供更好的用户体验。 在本系列的最后，您将创建一个小部件，该小部件： 显示多组数据。 当用户与该小部件的布局内的特定View交互时，执行唯一的操作。 在设定的时间段过后会...
phonegap-android硬件设备的调用
AdrianRD的博客
11-25 823
环境配置 插件安装 在创建phonegap工程后，进入到plugins文件夹下 根据自己所需要的功能添加响应插件 各项功能对应插件安装方法如下 //设备API cordovaplugin add org.apache.cordova.device                     //网络（事件）       cordovaplugin add o
Qt之 读取 /dev/input/event*设备 并解析
一个老菜鸟的学习分享
05-12 8128
qt 读取/dev/input/event 设备，并解析数据
触摸 屏
qq_45633736的博客
09-01 729
一、linux系统IO应用实例。 -> 触摸屏。 1、触摸屏设备叫什么名字？ 在linux下，一切都是文件，连触摸屏也是一个文件。 触摸屏设备名字：/dev/input/event0 2、熟悉了解触摸屏两个专业术语。 1）事件。 -> event0 当一些外接控制设备(鼠标、键盘，wifi，触摸屏，按键)接入到嵌入式平台(GEC6818)时，这些外接设备的状态发生了改变(鼠标的左键被按下了，键盘的R键被按下，有人连接上wifi了，触摸屏被滑动了一下，按键被按下了)时，这个动作就称之为事件。 .
linux input读取键盘,Linux键盘原始阅读，有什么更好的，从/ dev / input / event0读取或从标准输入读取？(Linux keyboard raw reading, wh...
weixin_42314399的博客
05-15 618
Linux键盘原始阅读，有什么更好的，从/ dev / input / event0读取或从标准输入读取？(Linux keyboard raw reading, what's better, reading from /dev/input/event0 or reading from stdin?)我正在为Raspberry Pi制作一个小型C视频游戏库。 我从头开始对输入系统进行编码，在阅读了...
嵌入式C编程规范：分层设计与最佳实践
- 驱动层（Driver Layer）：驱动层直接与硬件交互，提供对硬件设备的访问和控制，如控制蜂鸣器的响声。 2. **分层命名**： - 为了反映程序的层次结构，可以按照如下的目录结构组织代码：app（应用层）、logic...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值