多点触摸参考程序

最新推荐文章于 2021-09-29 16:01:34 发布
最新推荐文章于 2021-09-29 16:01:34 发布
阅读量1.6k 收藏 2
点赞数
分类专栏： Android多点触摸技术 文章标签： input struct report byte timer c

/* drivers/input/keyboard/synaptics_i2c_rmi.c
*
* Copyright (C) 2007 Google, Inc.
*
* This software is licensed under the terms of the GNU General Public
* License version 2, as published by the Free Software Foundation, and
* may be copied, distributed, and modified under those terms.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
* GNU General Public License for more details.
*
*/
#include <linux/module.h>;
#include <linux/delay.h>;
#include <linux/earlysuspend.h>;
#include <linux/hrtimer.h>;
#include <linux/i2c.h>;
#include <linux/input.h>;
#include <linux/interrupt.h>;
#include <linux/io.h>;
#include <linux/platform_device.h>;
#include <linux/synaptics_i2c_rmi.h>;
#include <asm/gpio.h>;
#include <plat/gpio-cfg.h>;
static struct workqueue_struct *synaptics_wq;
struct synaptics_ts_data {
        uint16_t addr;
        struct i2c_client *client;
        struct input_dev *input_dev;
        int use_irq;
        bool has_relative_report;
        struct hrtimer timer;
        struct work_struct  work;
        uint16_t max[2];
        int snap_state[2][2];
        int snap_down_on[2];
        int snap_down_off[2];
        int snap_up_on[2];
        int snap_up_off[2];
        int snap_down[2];
        int snap_up[2];
        uint32_t flags;
        int reported_finger_count;
        int8_t sensitivity_adjust;
        int (*power)(int on);
        struct early_suspend early_suspend;
};
#ifdef CONFIG_HAS_EARLYSUSPEND
static void synaptics_ts_early_suspend(struct early_suspend *h);
static void synaptics_ts_late_resume(struct early_suspend *h);
#endif
static int synaptics_init_panel(struct synaptics_ts_data *ts)
{
        int ret;
        ret = i2c_smbus_write_byte_data(ts->;client, 0x5b, 0x01);
        if (ret < 0)
                printk(KERN_ERR "i2c_smbus_write_byte_data failed for RESET/n");
        return ret;
}
static void synaptics_ts_work_func(struct work_struct *work)
{
        int i;
        int ret;
        int bad_data = 0;
        struct i2c_msg msg[2];
        uint8_t start_reg;
        uint8_t buf[24];
        struct synaptics_ts_data *ts = container_of(work, struct synaptics_ts_data, work);
        int buf_len = 24;
        int absmark=0;
        int fingermark=0;
        long int f1x,f1y,f1wx,f1wy,f1z,f2x,f2y,f2wx,f2wy,f2z;
        int ftemp;

        buf[0] = i2c_smbus_read_byte_data(ts->;client, 0x12);
        buf[1] = i2c_smbus_read_byte_data(ts->;client, 0x13);
        buf[2] = i2c_smbus_read_byte_data(ts->;client, 0x14);
        buf[3] = i2c_smbus_read_byte_data(ts->;client, 0x15);
        buf[4] = i2c_smbus_read_byte_data(ts->;client, 0x16);
        buf[5] = i2c_smbus_read_byte_data(ts->;client, 0x17);
        buf[6] = i2c_smbus_read_byte_data(ts->;client, 0x18);
        buf[7] = i2c_smbus_read_byte_data(ts->;client, 0x19);
        buf[8] = i2c_smbus_read_byte_data(ts->;client, 0x1a);
        buf[9] = i2c_smbus_read_byte_data(ts->;client, 0x1b);
        buf[10] = i2c_smbus_read_byte_data(ts->;client, 0x1c);
        buf[11] = i2c_smbus_read_byte_data(ts->;client, 0x1d);
        buf[12] = i2c_smbus_read_byte_data(ts->;client, 0x1e);
        buf[13] = i2c_smbus_read_byte_data(ts->;client, 0x1f);
        printk(KERN_INFO "M8 READ buf: %X %X %X %X %X %X %X %X %X %X %X %X %X %X/n",
                        buf[0],buf[1],buf[2],buf[3],buf[4],
                        buf[5],buf[6],buf[7],buf[8],buf[9],
                        buf[10],buf[11],buf[12],buf[13]);
        if(buf[2]==4) absmark=1;
        if(buf[3]==0x0a) fingermark=2;
        else if(buf[3]==0x01) fingermark=1;
        else fingermark=0;
        f1x=buf[4];
        f1x=f1x<<4;
        ftemp=(buf[6]&amp;0x0f);
        f1x=f1x+ftemp;
        f1y=buf[5];
        f1y=f1y<<4;
        ftemp=(buf[6]&amp;0xf0)>;>;4;
        f1y=f1y+ftemp;
        f1wx=(buf[7]&amp;0xf0)>;>;4;
        f1wy=(buf[7]&amp;0x0f);
        f1z=buf[8];
        f2x=buf[9];
        f2x=f2x<<4;
        ftemp=(buf[11]&amp;0x0f);
        f2x=f2x+ftemp;
        f2y=buf[10];
        f2y=f2y<<4;
        ftemp=(buf[11]&amp;0xf0)>;>;4;
        f2y=f2y+ftemp;
        f2wx=(buf[12]&amp;0xf0)>;>;4;
        f2wy=(buf[12]&amp;0x0f);
        f2z=buf[13];
        ftemp=f1y;
        f1y=f1x;
        f1x=2872-ftemp;
        ftemp=f2y;
        f2y=f2x;
        f2x=2872-ftemp;

        printk(KERN_INFO "f:%d,1x:%ld,1y:%ld,1wx:%ld,1wy:%ld,1z:%ld,2x:%ld,2y:%ld,2wx:%ld,2wy:%ld,2z:%ld/n",fingermark,f1x,f1y,f1wx,f1wy,f1z,f2x,f2y,f2wx,f2wy,f2z);

    if(fingermark==2)
    {
        input_report_key(ts->;input_dev,ABS_MT_TRACKING_ID,0);
        input_report_abs(ts->;input_dev, ABS_MT_TOUCH_MAJOR, f1z);
        input_report_abs(ts->;input_dev, ABS_MT_POSITION_X, f1x);
        input_report_abs(ts->;input_dev, ABS_MT_POSITION_Y, f1y);
        input_mt_sync(ts->;input_dev);
        input_report_key(ts->;input_dev,ABS_MT_TRACKING_ID,1);
        input_report_abs(ts->;input_dev, ABS_MT_TOUCH_MAJOR, f2z);
        input_report_abs(ts->;input_dev, ABS_MT_POSITION_X, f2x);
        input_report_abs(ts->;input_dev, ABS_MT_POSITION_Y, f2y);
        input_mt_sync(ts->;input_dev)
        input_sync(ts->;input_dev);
    }
    else if(fingermark==1)
    {
        input_report_key(ts->;input_dev,ABS_MT_TRACKING_ID,0);
        input_report_abs(ts->;input_dev, ABS_MT_TOUCH_MAJOR, f1z);
        input_report_abs(ts->;input_dev, ABS_MT_POSITION_X, f1x);
        input_report_abs(ts->;input_dev, ABS_MT_POSITION_Y, f1y);
        input_mt_sync(ts->;input_dev);
        input_sync(ts->;input_dev);
    }
    else
    {
        input_report_abs(ts->;input_dev, ABS_MT_TOUCH_MAJOR, 0);
        input_mt_sync(ts->;input_dev);
        input_sync(ts->;input_dev);
    }


        /*if(f1z)
        {
                input_report_abs(ts->;input_dev, ABS_X, f1x);
                input_report_abs(ts->;input_dev, ABS_Y, f1y);
                input_report_abs(ts->;input_dev, ABS_PRESSURE, f1z);
                if(fingermark==2)
                {
                        input_report_key(ts->;input_dev, BTN_2, 1);
                        input_sync(ts->;input_dev);
                        input_report_abs(ts->;input_dev, ABS_HAT0X, f2x);
                        input_report_abs(ts->;input_dev, ABS_HAT0Y, f2y);
                        input_report_key(ts->;input_dev, BTN_TOUCH, 1);
                }
                else if(fingermark==1)
                {
                        input_report_key(ts->;input_dev, BTN_2, 0);
                        input_report_key(ts->;input_dev, BTN_TOUCH, 1);
                }
                else
                {
                        input_report_key(ts->;input_dev, BTN_TOUCH, 0);
                }
        }
        else
        {
                input_report_key(ts->;input_dev, BTN_TOUCH, 0);
                input_report_abs(ts->;input_dev, ABS_MT_TOUCH_MAJOR, 0);
                input_report_abs(ts->;input_dev, ABS_MT_WIDTH_MAJOR, 0);
                input_report_abs(ts->;input_dev, ABS_MT_POSITION_X, f1x);
                input_report_abs(ts->;input_dev, ABS_MT_POSITION_Y, f1y);
                input_mt_sync(ts->;input_dev);
        }
        input_sync(ts->;input_dev);*/
        if (ts->;use_irq)
                enable_irq(ts->;client->;irq);
}
static enum hrtimer_restart synaptics_ts_timer_func(struct hrtimer *timer)
{
        struct synaptics_ts_data *ts = container_of(timer, struct synaptics_ts_data, timer);
        /* printk("synaptics_ts_timer_func/n"); */
        queue_work(synaptics_wq, &amp;ts->;work);
        hrtimer_start(&amp;ts->;timer, ktime_set(0, 12500000), HRTIMER_MODE_REL);
        return HRTIMER_NORESTART;
}
static irqreturn_t synaptics_ts_irq_handler(int irq, void *dev_id)
{
        struct synaptics_ts_data *ts = dev_id;
        disable_irq_nosync(ts->;client->;irq);
        queue_work(synaptics_wq, &amp;ts->;work);
        return IRQ_HANDLED;
}
static int synaptics_ts_probe(
        struct i2c_client *client, const struct i2c_device_id *id)
{
        struct synaptics_ts_data *ts;
        int ret = 0;
        unsigned long irqflags;
        long int max_x,max_y,max_temp;
        if (!i2c_check_functionality(client->;adapter, I2C_FUNC_I2C)) {
                printk(KERN_ERR "synaptics_ts_probe: need I2C_FUNC_I2C/n");
                ret = -ENODEV;
                goto err_check_functionality_failed;
        }
        ts = kzalloc(sizeof(*ts), GFP_KERNEL);
        if (ts == NULL) {
                ret = -ENOMEM;
                goto err_alloc_data_failed;
        }
        INIT_WORK(&amp;ts->;work, synaptics_ts_work_func);
        ts->;client = client;
        i2c_set_clientdata(client, ts);

        ts->;input_dev = input_allocate_device();
        if (ts->;input_dev == NULL) {
                ret = -ENOMEM;
                printk(KERN_ERR "synaptics_ts_probe: Failed to allocate input device/n");
                goto err_input_dev_alloc_failed;
        }
        ts->;input_dev->;name = "synaptics-rmi-touchscreen";

        set_bit(EV_SYN, ts->;input_dev->;evbit);
        set_bit(EV_KEY, ts->;input_dev->;evbit);
        set_bit(BTN_TOUCH, ts->;input_dev->;keybit);
        set_bit(BTN_2, ts->;input_dev->;keybit);
        set_bit(EV_ABS, ts->;input_dev->;evbit);

        /*max_x = i2c_smbus_read_byte_data(ts->;client, 0x28);
        max_temp = i2c_smbus_read_byte_data(ts->;client, 0x29);
        max_x=max_x+max_temp<<8;
        max_y = i2c_smbus_read_byte_data(ts->;client, 0x2a);
        max_temp = i2c_smbus_read_byte_data(ts->;client, 0x2b);
        max_y=max_y+max_temp<<8;
        printk(KERN_INFO "max_x:%ld,max_y:%ld/n",max_x,max_y);*/
        max_x=0x77b;
        max_y=0xb38;

        input_set_abs_params(ts->;input_dev, ABS_X, 0, max_y, 0, 0);
        input_set_abs_params(ts->;input_dev, ABS_Y, 0, max_x, 0, 0);
        input_set_abs_params(ts->;input_dev, ABS_PRESSURE, 0, 255, 0, 0);
        input_set_abs_params(ts->;input_dev, ABS_TOOL_WIDTH, 0, 15, 0, 0);
        input_set_abs_params(ts->;input_dev, ABS_HAT0X, 0, max_y, 0, 0);
        input_set_abs_params(ts->;input_dev, ABS_HAT0Y, 0, max_x, 0, 0);
        input_set_abs_params(ts->;input_dev, ABS_MT_POSITION_X, 0, max_y, 0, 0);
        input_set_abs_params(ts->;input_dev, ABS_MT_POSITION_Y, 0, max_x, 0, 0);
        input_set_abs_params(ts->;input_dev, ABS_MT_TOUCH_MAJOR, 0, 255, 0, 0);
        input_set_abs_params(ts->;input_dev, ABS_MT_WIDTH_MAJOR, 0, 15, 0, 0);
        /* ts->;input_dev->;name = ts->;keypad_info->;name; */
        ret = input_register_device(ts->;input_dev);
        if (ret) {
                printk(KERN_ERR "synaptics_ts_probe: Unable to register %s input device/n", ts->;input_dev->;name);
                goto err_input_register_device_failed;
        }
        /*add by meizu to support interrupt mode*/
        s3c_gpio_cfgpin(S3C64XX_GPN(15),S3C_GPIO_SFN(2));
        client->;irq = gpio_to_irq(S3C64XX_GPN(15));
        irqflags = IRQF_TRIGGER_LOW;
        /*add end*/
        if (client->;irq) {
                ret = request_irq(client->;irq, synaptics_ts_irq_handler, irqflags, client->;name, ts);
                #if 0
                if (ret == 0) {
                        ret = i2c_smbus_write_byte_data(ts->;client, 0xf1, 0x01); /* enable abs int */
                        if (ret)
                                free_irq(client->;irq, ts);
                }
                #endif
                if (ret == 0)
                        ts->;use_irq = 1;
                else
                        dev_err(&amp;client->;dev, "request_irq failed/n");
        }
        if (!ts->;use_irq) {
                hrtimer_init(&amp;ts->;timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL);
                ts->;timer.function = synaptics_ts_timer_func;
                hrtimer_start(&amp;ts->;timer, ktime_set(10, 0), HRTIMER_MODE_REL);
        }
#ifdef CONFIG_HAS_EARLYSUSPEND
        ts->;early_suspend.level = EARLY_SUSPEND_LEVEL_BLANK_SCREEN + 1;
        ts->;early_suspend.suspend = synaptics_ts_early_suspend;
        ts->;early_suspend.resume = synaptics_ts_late_resume;
        register_early_suspend(&amp;ts->;early_suspend);
#endif
        printk(KERN_INFO "synaptics_ts_probe: Start touchscreen %s in %s mode/n", ts->;input_dev->;name, ts->;use_irq ? "interrupt" : "polling");
        return 0;
err_input_register_device_failed:
        input_free_device(ts->;input_dev);
err_input_dev_alloc_failed:
err_detect_failed:
err_power_failed:
        kfree(ts);
err_alloc_data_failed:
err_check_functionality_failed:
        return ret;
}
static int synaptics_ts_remove(struct i2c_client *client)
{
        struct synaptics_ts_data *ts = i2c_get_clientdata(client);
        unregister_early_suspend(&amp;ts->;early_suspend);
        if (ts->;use_irq)
                free_irq(client->;irq, ts);
        else
                hrtimer_cancel(&amp;ts->;timer);
        input_unregister_device(ts->;input_dev);
        kfree(ts);
        return 0;
}
static int synaptics_ts_suspend(struct i2c_client *client, pm_message_t mesg)
{
        int ret;
        struct synaptics_ts_data *ts = i2c_get_clientdata(client);
        if (ts->;use_irq)
                disable_irq(client->;irq);
        else
                hrtimer_cancel(&amp;ts->;timer);
        ret = cancel_work_sync(&amp;ts->;work);
        if (ret &amp;&amp; ts->;use_irq) /* if work was pending disable-count is now 2 */
                enable_irq(client->;irq);
        ret = i2c_smbus_write_byte_data(ts->;client, 0xf1, 0); /* disable interrupt */
        if (ret < 0)
                printk(KERN_ERR "synaptics_ts_suspend: i2c_smbus_write_byte_data failed/n");
        ret = i2c_smbus_write_byte_data(client, 0xf0, 0x86); /* deep sleep */
        if (ret < 0)
                printk(KERN_ERR "synaptics_ts_suspend: i2c_smbus_write_byte_data failed/n");
        if (ts->;power) {
                ret = ts->;power(0);
                if (ret < 0)
                        printk(KERN_ERR "synaptics_ts_resume power off failed/n");
        }
        return 0;
}
static int synaptics_ts_resume(struct i2c_client *client)
{
        int ret;
        struct synaptics_ts_data *ts = i2c_get_clientdata(client);
        if (ts->;power) {
                ret = ts->;power(1);
                if (ret < 0)
                        printk(KERN_ERR "synaptics_ts_resume power on failed/n");
        }
        synaptics_init_panel(ts);
        if (ts->;use_irq)
                enable_irq(client->;irq);
        if (!ts->;use_irq)
                hrtimer_start(&amp;ts->;timer, ktime_set(1, 0), HRTIMER_MODE_REL);
        else
                i2c_smbus_write_byte_data(ts->;client, 0xf1, 0x01); /* enable abs int */
        return 0;
}
#ifdef CONFIG_HAS_EARLYSUSPEND
static void synaptics_ts_early_suspend(struct early_suspend *h)
{
        struct synaptics_ts_data *ts;
        ts = container_of(h, struct synaptics_ts_data, early_suspend);
        synaptics_ts_suspend(ts->;client, PMSG_SUSPEND);
}
static void synaptics_ts_late_resume(struct early_suspend *h)
{
        struct synaptics_ts_data *ts;
        ts = container_of(h, struct synaptics_ts_data, early_suspend);
        synaptics_ts_resume(ts->;client);
}
#endif
static const struct i2c_device_id synaptics_ts_id[] = {
        { SYNAPTICS_I2C_RMI_NAME, 0 },
        { }
};
static struct i2c_driver synaptics_ts_driver = {
        .probe                = synaptics_ts_probe,
        .remove                = synaptics_ts_remove,
#ifndef CONFIG_HAS_EARLYSUSPEND
        .suspend        = synaptics_ts_suspend,
        .resume                = synaptics_ts_resume,
#endif
        .id_table        = synaptics_ts_id,
        .driver = {
                .name        = SYNAPTICS_I2C_RMI_NAME,
        },
};
static int __devinit synaptics_ts_init(void)
{
        synaptics_wq = create_singlethread_workqueue("synaptics_wq");
        if (!synaptics_wq)
                return -ENOMEM;
        return i2c_add_driver(&amp;synaptics_ts_driver);
}
static void __exit synaptics_ts_exit(void)
{
        i2c_del_driver(&amp;synaptics_ts_driver);
        if (synaptics_wq)
                destroy_workqueue(synaptics_wq);
}
module_init(synaptics_ts_init);
module_exit(synaptics_ts_exit);
MODULE_DESCRIPTION("Synaptics Touchscreen Driver");
MODULE_LICENSE("GPL");

Android_Man
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java层的多点触摸程序
11-13
从其他那里下载的, 只要2分,里面加入一个对应的html详细说明,供参考
多点触碰开发
ypynetboy的专栏
11-15 867
多点触摸multi-touch<br /> 最近研究多点触摸，做了个demo。Demo中实现多点触摸缩放和使用按钮点击放大和缩小。注意2.0以上才支持多点触摸。 <br /><br /> 程序代码如下： <br /> package org.example.touch; <br />
06.输入系统：第10课第24节_输入系统_多点触摸驱动程序_InputStage
江南才尽江南山，年少无知年少狂！
03-22 427
在前面的小节中，我们以按键的实例，详细的讲解InputStage，该小节多点触摸屏的InputStage，看看Reader线程是如何处理他的，在这之前先来回顾一下之前的知识。 我们知道一个应用程序APP有多个activity，每个activity对应一个window，在window中存在Decorview，我们可以从其中划出一块区域，然后自由创作，比如在上面增加TextView，Button等等。......
Linux内核高精度定时器hrtimer的使用
zjy764219923的专栏
06-10 4424
Linux内核高精度定时器hrtimer的使用 hrtimer:(high resolution timer)： 高精度定时器，为我们提供了纳秒级别的定时精度，以满足对精确时间有迫切需求的应用程序或内核驱动。因原有定时器已经相对完善，避免大幅度改动，内核为高精度定时器重新设计了一台软件架构。 /** * struct hrtimer - the basic hrtimer structure * @node: timerqueue node, which also manages node.ex
linux ktime set函数,ktime使用例子【原创】
weixin_30320081的博客
05-15 2066
#include #include #include #include #include static void time_get(ktime_t *start);static void time_get(ktime_t *start){*start = ktime_get();}static int time_print(const char *name, ktime_t starttime){...
Windows多点触摸USB协议_多点触摸HID报文
04-20
根据给定文件信息，以下是对“Windows多点触摸USB协议_多点触摸HID报文”的知识点详细说明： ...这些内容对于开发Windows平台的触摸屏和多点触摸设备驱动程序的人员来说，都是非常重要的参考信息。
多点触摸 ontuch
10-22
总的来说，这个"muti-touch"资源包对于想要实现多点触摸功能的开发者来说是一份宝贵的参考资料。通过深入研究和实践，开发者不仅可以掌握多点触摸的基本原理，还能熟练地将其应用到各种应用场景，提升用户的交互体验...
基于有限状态机的Linux多点触摸屏驱动设计.pdf
09-06
总的来说，基于有限状态机的Linux多点触摸屏驱动设计是一种有效的方法，它能够提高驱动程序对触摸屏输入的处理能力，优化手势识别，减少错误和延迟，从而提供更加可靠和灵敏的用户体验。这对于生产嵌入式手持设备的...
android多点触摸实例及疑问
03-24
总之，Android的多点触摸功能为开发者提供了丰富的交互方式，通过理解和熟练运用`MotionEvent`和相关工具类，我们可以创建出更加生动、富有交互性的应用程序。在实践中遇到问题时，可以参考文档、博客（如给定的博文...
linux 内核定时器（高精度）
09-29 1115
在实际的项目实践中，驱动的实现过程中要求我们实现较高的精度，比如Linux内核使用gpio模拟 实现串口驱动，在这种驱动的实现过程中，由于没有时钟线，所以在TTL电平的模拟中他的时钟沿 的变化的时间精度要求还是比较高的。此时，我们就必须使用高精度的内核定时器hrtimer来实现。 在使用高精度的内核定时器之前，我们必须首先在Linux内核配置选项中进行相关的配置，以确认 自己所使用的Linux内核支持高精度的定时器，如下： Kernel Features ---> [*] ...
linux下jiffies定时器和hrtimer高精度定时器
热门推荐
dosculler的专栏
09-01 1万+
一、jiffies定时器，HZ=100，精度只能达到10ms。 注：采用jiffies+msecs_to_jiffies(xx ms);可做到ms级，不过精度不够   #include //DO-->jiffies调用头文件 #include   //DO-->timer_list结构体 static struct timer_list ms_timer;//DO-->定义timer_l
内核子系统运用--定时器的使用
weixin_41884251的博客
11-12 318
linux内核定时器使用 高精度定时器 内核配置打开timers子系统中的高精度定时器 general-setup -》》timer subsys -》》 high resolution timer support 初始化 struct hrtimer hr_timer; hrtimer_init(&(hr_timer), CLOCK_MONOTONIC, HRTIMER_MODE_REL);//定时器注册 hr_timer.function = hrtimer_hander; //中断处理函数 h
linux 内核定时器最小值,linux内核定时器
weixin_35745051的博客
04-30 368
Linux内核定时器是内核用来控制在未来某个时间点(基于jiffies)调度执行某个函数的一种机制，调度函数在运行过一次后就不会再运行了(相当于自动注销)，但可以通过在被调度的函数中重新调度自己来周期运行。(1)jiffies定时器，HZ=100，精度只能达到10ms，已验证#include #include static struct timer_list ms_timer;static voi...
ktime使用例子【原创】
weixin_33811539的博客
04-13 193
#include &lt;linux/kernel.h&gt;#include &lt;linux/init.h&gt;#include &lt;linux/module.h&gt;#include &lt;linux/delay.h&gt;#include &lt;linux/interrupt.h&gt; static void time_get(ktime_t *start); stat...
linux 内核 时间函数吗,Linux内核中的时间函数
weixin_42350606的博客
05-01 919
ktime时间函数基于ktime_t格式的时间ktime_t ktime_get(void);获取基于CLOCK_MONOTONIC的当前时间，返回ktime_t格式的数据类型。单调递增的，一般认为它不会受到NTP的影响，用户修改墙上时间，不会对这个产生影响。内核一般可以用这个来统计延时时间。ktime_t ktime_get_boottime(void);获取基于CLOCK_BOOTTIME的当...
Linux 内核定时器使用 二 高精度定时器 hrtimer 的用例
fuyuande的博客
08-29 8773
之前介绍了timer_list内核定时器，它的精度在毫秒级别，再高一点它就无能为力了，所幸内核提供了高精度定时器 hrtimer。 源文件在linux/kernel/hrtimer.c中。接口简单。下面介绍一下相关接口 1. 定时器定义与绑定超时回调函数 static struct hrtimer timer; /* 设置回调函数 */ timer.function = hrtimer_h...
Linux驱动 hrtimer定时器分析
xhao1985的博客
05-23 1247
1，相关头文件：#include &lt;linux/hrtimer.h&gt;#include &lt;linux/jiffies.h&gt;#include &lt;linux/timer.h&gt;hrtimer为高分辨率kernel定时器，可以作为超时或周期性定时器使用。相关函数说明：1）hrtimer初始化：void hrtimer_init(struct hrtimer *timer,...
多点触摸技术探索：自然用户界面的开源指南
此外，软件层面，如驱动程序开发、事件处理和用户界面设计也是多点触摸技术实现的关键环节。 书中还可能探讨了硬件构建和调试，包括如何组装触摸感应层、处理单元和显示器，以及如何进行系统集成和性能优化。对于...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值