内核定时器API实现点灯

1.内核定时器        

       定时器是一个很常用的功能，需要周期性处理的工作都要用到定时器。 Linux 内核定时器
采用系统时钟来实现，并不是6ull里面的硬件定时器。 Linux 内核定时器使用很简单，只需要提供超时时间(相当于定时值)和定时处理函数即可，当超时时间到了以后设置的定时处理函数就会执行，和我们使用硬件定时器的套路一样，只是使用内核定时器不需要做一大堆的寄存器初始化工作。在使用内核定时器的时候要注意一点，内核定时器并不是周期性运行的，超时以后就会自动关闭，因此如果想要实现周期性定时，那么就需要在定时处理函数中重新开启定时器。
        Linux 内核使用 timer_list 结构体表示内核定时器， timer_list 定义在文件include/linux/timer.h 中，定义如下：

struct timer_list {
    /*
     * All fields that change during normal runtime grouped to the
     * same cacheline
     */
    struct list_head entry;
    unsigned long expires;                 /* 定时器超时时间，单位是节拍数 */
    struct tvec_base *base;
 
    void (*function)(unsigned long);       /* 定时处理函数 */
    unsigned long data;                    /* 要传递给 function 函数的参数 */
 
    int slack;
 
#ifdef CONFIG_TIMER_STATS
    int start_pid;
    void *start_site;
    char start_comm[16];
#endif
#ifdef CONFIG_LOCKDEP
    struct lockdep_map lockdep_map;
#endif
};

 =========================

 2.内核定时器API函数    

      要使用内核定时器首先要先定义一个 timer_list 变量，表示定时器， tiemr_list 结构体的
expires 成员变量表示超时时间，单位为节拍数。比如我们现在需要定义一个周期为 2 秒的定时
器，那么这个定时器的超时时间就是 jiffies+msecs_to_jiffies（2000），function 就是定时器超时以后的定时处理函数，当定时时间到了以后，就会跳转到function执行。

        定义好定时器后，还需要API函数（定义在linux/timer.h）来初始化定时器：

        ①、init_timer函数
        init_timer 函数负责初始化 timer_list 类型变量，函数原型：

#define init_timer(timer)                        \
    __init_timer((timer), 0)
 
#define __init_timer(_timer, _flags)                    \
    init_timer_key((_timer), (_flags), NULL, NULL)
 
void init_timer_key(struct timer_list *timer, unsigned int flags,
            const char *name, struct lock_class_key *key)
    timer：要初始化的定时器。

   

        ②、add_timer函数
         用于向 Linux 内核注册定时器，使用 add_timer 函数向内核注册定时器以后，定时器就会开始运行，函数原型如下：

extern void add_timer(struct timer_list *timer);
timer：要初始化的定时器。

        ③、del_timer函数
        用于删除一个定时器，不管定时器有没有被激活，都可以使用此函数删除。在多处理器系统上，定时器可能会在其他的处理器上运行，因此在调用 del_timer 函数删除定时器之前要先等待其他处理器的定时处理器函数退出，函数原型：

extern int del_timer(struct timer_list * timer);
         timer：要初始化的定时器。
返回值：0，定时器没被激活，1，定时已经激活。

        ④、del_timer_sync函数
        函数是 del_timer 函数的同步版，会等待其他处理器使用完定时器再删除，del_timer_sync 不能使用在中断上下文中。函数原型：

extern int try_to_del_timer_sync(struct timer_list *timer);
timer：要初始化的定时器。

返回值：0，定时器没被激活，1，定时已经激活。

        ⑤、mod_timer函数
        用于修改定时值，如果定时器还没有激活的话， mod_timer 函数会激活定时器！函数原型如下：

extern int mod_timer(struct timer_list *timer, unsigned long expires);
timer：要修改超时时间的定时器。

expires：修改后的超时时间。

返回值：0，调用 mod_timer 函数前定时器未被激活； 1，调用 mod_timer 函数前定时器已被激活。

 ===============================

  3.内核定时器的使用流程
struct timer_list timer; /* 定义定时器 */
 
/* 定时器回调函数 */
void function(unsigned long arg)
{
    /*
     * 定时器处理代码
     */
 
    /* 如果需要定时器周期性运行的话就使用 mod_timer
     * 函数重新设置超时值并且启动定时器。
     */
 
    mod_timer(&dev->timertest, jiffies + msecs_to_jiffies(2000));    /* 修改超时时间为2s */
}
 
/* 初始化函数 */
void init(void)
{
    init_timer(&timer); /* 初始化定时器 */
 
    timer.function = function; /* 设置定时处理函数 */
    timer.expires=jffies + msecs_to_jiffies(2000);/* 超时时间 2 秒 */
    timer.data = (unsigned long)&dev; /* 将设备结构体作为参数 */
 
    add_timer(&timer); /* 启动定时器 */
}
 
/* 退出函数 */
 
void exit(void)
{
    del_timer(&timer); /* 删除定时器 */
    /* 或者使用 */
    del_timer_sync(&timer);
}
4.Linux内核短延时函数


        有时候我们需要在内核中实现短延时，尤其是在 Linux 驱动中。 Linux 内核提供了毫秒、微秒和纳秒延时函数，如表：

函数描述

void ndelay(unsigned long nsecs)  
void udelay(unsigned long usecs)
void mdelay(unsigned long mseces)
//  ms、us、ns延时函数


unlocked_ioctl和compat_ioctl
        函数简介：
        unlocked_ioctl\compat_ioctl是file_operation 结构体中的两个函数

        unlocked_ioctl函数提供对于设备的控制功能，与应用程序中的 ioctl 函数对应。简单点来说，当用户空间应用程序调用 ioctl函数向驱动发送控制信息，驱动程序会执行unlocked_ioctl这个函数

long (*unlocked_ioctl) (struct file *filep, unsigned int cmd, unsigned long arg);
        filep：设备文件名。
        cmd：应用程序发送过来的命令信息。后面我们会仔细说一下这个CMD命令如何创建。
        arg：应用程序发过来的参数。

         compat_ioctl函数的功能与unlocked_ioctl函数一样，区别在于64 位系统上，32 位的应用程序调用将会使用此函数。在 32 位的系统上运行 32 位的应用程序调用的是unlocked_ioctl。

long (*compat_ioctl) (struct file *filep, unsigned int cmd, unsigned long arg)；

===========================


     5.ioctl函数CMD命令


        在linux内核中有帮助手册：linux/Documentation/ioctl/ioctl-decoding.txt这个文档中有介绍CMD这个命令：

#define _IO(type,nr)        _IOC(_IOC_NONE,(type),(nr),0)
#define _IOR(type,nr,size)  _IOC(_IOC_READ,(type),(nr),(_IOC_TYPECHECK(size)))
#define _IOW(type,nr,size)  _IOC(_IOC_WRITE,(type),(nr),(_IOC_TYPECHECK(size)))
#define _IOWR(type,nr,size) _IOC(_IOC_READ|_IOC_WRITE,(type),(nr),(_IOC_TYPECHECK(size)))


#define _IOC(dir,type,nr,size) \
    (((dir)  << _IOC_DIRSHIFT) | \     //dir（读写）方向左移30位
     ((type) << _IOC_TYPESHIFT) | \    //type类型左移8位
     ((nr)   << _IOC_NRSHIFT) | \      //nr功能左移0位
     ((size) << _IOC_SIZESHIFT))      // size传递数据大小左移16位
 /**通过分析是dir、type、nr、size几个数都左移了一个不知道的宏的位数，通过查找发现这些宏如下，
 所以得到上边每行注释左移位数**/
#define _IOC_NRBITS 8                                                                                   
#define _IOC_TYPEBITS   8
# define _IOC_SIZEBITS  14
#define _IOC_NRSHIFT    0
#define _IOC_TYPESHIFT  (_IOC_NRSHIFT+_IOC_NRBITS)  // 0+8 = 8                                                     
#define _IOC_SIZESHIFT  (_IOC_TYPESHIFT+_IOC_TYPEBITS) //8+8 = 16
#define _IOC_DIRSHIFT   (_IOC_SIZESHIFT+_IOC_SIZEBITS) //16+14 = 30

总结：我们通过分析_IOC这个宏可以发现他做了这么一件事，将一个32位的数拆成了四个部分，分别是dir、type、nr、size，分别如下解释和图示：
bit31~bit30：“区别读写” 区，作用是区分是读取命令还是写入命令；
bit29~bit16：“数据大小” 区，表示 ioctl() 中的 arg 变量传送的内存大小。
bit15~bit8 ： “ 魔数” (也称为"幻数")区，这个值用以与其它设备驱动程序的 ioctl 命令进行区别。
bit7~bit0 ：“区别序号”区，是区分命令的命令顺序序号
 

                            

这个CMD是一个32位的。31~30位是方向位，_IOR是向驱序读，_IOW是向驱动写。29~16位是用户空间向内核空间传输控制信息的数据大小，15~8位表示类型，驱动的标识位，一个特殊字符（ASCII）代表不同的一个驱动。7~0位就是不同的控制功能。

===========================

内核代码：
#include <linux/module.h>
#include <linux/fs.h>
#include <linux/kernel.h>
#include <linux/init.h>
#include <linux/ide.h>
#include <linux/types.h>
#include <linux/uaccess.h>
#include <asm/io.h>
#include <linux/device.h>
#include <linux/cdev.h>
#include <linux/of.h>
#include <linux/of_address.h>
#include <linux/errno.h>
#include <linux/of_gpio.h>
#include <linux/gpio.h>
#include <asm/mach/map.h>
#include <linux/timer.h>
#include <linux/jiffies.h>
#include <linux/delay.h>
#include <linux/semaphore.h>
#include <asm/ioctls.h>
 
 
/* 设备名称和个数 */
#define TIMER_CNT           1
#define TIMER_NAME          "timer"
 
  
/* 命令宏 */
#define OPEN_CMD            _IO('E', 1)
#define CLOSE_CMD           _IO('E', 2)
#define SET_PERIOD_CMD      _IOW('E', 3, int)    
 
 
 
/* timer结构体 */
typedef struct timer_dev {
    dev_t devid;                        /* 设备号 */
    int major;                          /* 主设备号 */
    int minor;                          /* 次设备号 */
    struct cdev dev;                    /* 设备 */
    struct class *class;                /* 类 */
    struct device *device;              /* 类的设备 */
    struct device_node  *nd;             /* 设备树节点 */
    int led_gpio;                       /* LED的GPIO编号 */
    struct timer_list timer;            /* 定时器 */
 
    int timerperiod;                    /* 定时器周期 */
    spinlock_t lock;                    /* 自旋锁 */
 
}timer_dev;
timer_dev timer;
 
static int timer_open (struct inode *inode, struct file *filep)
{
 
    filep->private_data = &timer;       /* 设置私有数据 */
 
    timer.timerperiod = 500;           /* 设置定时时间为1s */
 
    return 0;
}
 
 
static long timer_unlocked_ioctlioctl(struct file *filep, unsigned int cmd, unsigned long arg)
{
    int ret = 0;
    timer_dev *dev = filep->private_data;    /* 获取私有数据 */
    unsigned int timerperod = 0;
    unsigned long flag = 0;
    unsigned long value = 0;
 
	switch (cmd) {
	    case OPEN_CMD:         /*  打开定时器 */
 
            spin_lock_irqsave(&dev->lock,flag);        /* 自锁 */
            timerperod = dev->timerperiod;
            spin_unlock_irqrestore(&dev->lock,flag);   /* 解锁 */
            mod_timer(&dev->timer,jiffies + msecs_to_jiffies(timerperod));
            break;
	    case CLOSE_CMD:         /* 关闭定时器 */
            del_timer(&dev->timer);
            break;
        case SET_PERIOD_CMD:     /*  修改定时器的周期  */
            ret = copy_from_user(&value, (int *)arg, sizeof(int));
            if(ret < 0) {
                return -EFAULT;
            }
            spin_lock_irqsave(&dev->lock,flag);
            dev->timerperiod = value;
            spin_unlock_irqrestore(&dev->lock,flag);
            mod_timer(&dev->timer,jiffies + msecs_to_jiffies(value));
            break;
	}
    return 0;
 
}
 
 
 
/* 设备文件操作集合 */
const struct file_operations timer_opts = {
    .owner = THIS_MODULE,
    .open = timer_open,
    .unlocked_ioctl = timer_unlocked_ioctlioctl,
};
 
/* LED灯初始化 */
int led_init(timer_dev * ptimer)
{
    int ret = 0;
    
    timer_dev *dev = ptimer;
 
    /* 获取LED节点和信息 */
    dev->nd = of_find_node_by_path("/gpioled");
 
    /* 得到GPIO的编号 */
    dev->led_gpio = of_get_named_gpio(dev->nd, "led-gpio", 0);
    if(dev->led_gpio < 0) {
        ret = -EINVAL;
        printk("fail get gpio\r\n");
        goto fail_getgpio;
    }
 
    /* 申请GPIO */
    ret = gpio_request(dev->led_gpio, "led_gpio");
    if(ret) {
        printk("fail gpio request\r\n");
        ret = -EBUSY;
        goto fail_request;
    }
 
    /* 设置GPIO输入输出 */
    ret = gpio_direction_output(dev->led_gpio, 1);           /* 输出模式 给1关灯，默认关灯 */
    if(ret){
        printk("fail gpio set output\r\n");
        ret = -EBUSY;
        goto fail_setout;
    }
 
    return 0;
fail_setout:
    gpio_free(dev->led_gpio);
fail_request:
fail_getgpio:
    return ret;
}
 
/* 定时器定时时间到回调函数 */
void  timer_timerout (unsigned long arg)
{
    static int status = 1;
    unsigned long flags;
    int timerperiod  = 0;
    timer_dev *dev = (timer_dev *)arg;
 
    /* 设置LED灯电平 */
    status = !status;
    gpio_set_value(dev->led_gpio,status);
 
    spin_lock_irqsave(&dev->lock,flags);                    /* 自锁 */
    timerperiod = dev->timerperiod;
    spin_unlock_irqrestore(&dev->lock, flags);               /* 解锁 */
 
    mod_timer(&dev->timer, jiffies + msecs_to_jiffies(timerperiod));
}
 
 
/* 入口函数 */
static int __init timer_init(void)
{
    int ret = 0;
 
    /* 初始化自旋锁 */
    spin_lock_init(&timer.lock);
    timer.timerperiod = 500;
 
    /* 注册设备号 */
    timer.major = 0;
    if(timer.major) {       /* 指定设备号 */
        timer.devid = MKDEV(timer.major,0);
        ret = register_chrdev_region(timer.devid, TIMER_CNT, TIMER_NAME);
    }else {                 /* 没有指定设备号 */
        ret = alloc_chrdev_region(&timer.devid, 0, TIMER_CNT, TIMER_NAME);
        timer.major = MAJOR(timer.devid);
        timer.minor = MINOR(timer.devid);
    }
    if(ret < 0) {
        printk("fail devid\r\n");
        goto fail_devid;
    }
    printk("major = %d,minor = %d\r\n",timer.major,timer.minor);            /* 打印设备号 */
 
    /* 注册设备 */
    timer.dev.owner = THIS_MODULE;
    cdev_init(&timer.dev, &timer_opts);
    ret = cdev_add(&timer.dev, timer.devid, TIMER_CNT);
    if(ret < 0) {
        printk("fail dev\r\n");
        goto fail_dev;
    }
 
    /* 自动创建节点信息 */
    timer.class = class_create(THIS_MODULE, TIMER_NAME);
    if(IS_ERR(timer.class)) {
        ret = PTR_ERR(timer.class);
        printk("fail class\r\n");
        goto fail_class;
    }
    timer.device = device_create(timer.class, NULL, timer.devid, NULL, TIMER_NAME);
    if(IS_ERR(timer.device)) {
        ret = PTR_ERR(timer.device);
        printk("fail device\r\n");
        goto fail_device;
    }
 
    /* 初始化LED灯 */
    ret = led_init(&timer);
    if(ret < 0) {
        printk("fail led init\r\n");
        goto fail_led_init;
    }
 
    /* 初始化定时器 */
    init_timer(&timer.timer);
    timer.timer.data = (unsigned long) &timer;
    timer.timer.function = timer_timerout;
    mod_timer(&timer.timer, jiffies + msecs_to_jiffies(timer.timerperiod));
 
    return 0;
 
fail_led_init:
fail_device:
    class_destroy(timer.class);
fail_class:
    cdev_del(&timer.dev);
fail_dev:
    unregister_chrdev_region(timer.devid, TIMER_CNT);
fail_devid:
    return ret;
}
 
 
/* 出口函数 */
static void __exit timer_exit(void)
{
    /* 关灯 */
    gpio_set_value(timer.led_gpio, 1);
 
    /* 删除定时器 */
    del_timer_sync(&timer.timer);
 
    /* 注销GPIO */
    gpio_free(timer.led_gpio);
 
    /* 删除类的设备 */
    device_destroy(timer.class, timer.devid);
 
    /* 删除类 */
    class_destroy(timer.class);
 
    /* 删除设备 */
    cdev_del(&timer.dev);
 
    /* 删除设备号 */
    unregister_chrdev_region(timer.devid, TIMER_CNT);
    
    printk("timer exit\r\n");
}
 
 
/* 注册入口和出口函数 */
module_init(timer_init);
module_exit(timer_exit);
MODULE_LICENSE("GPL");
MODULE_AUTHOR("ZhangXueGuo");
上层代码编写

============

#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <stdlib.h>
#include <sys/ioctl.h>
 
 
 
/* 命令宏 */
#define OPEN_CMD            _IO('E', 1)
#define CLOSE_CMD           _IO('E', 2)
#define SET_PERIOD_CMD      _IOW('E', 3, int)  
 
/*
 *  main主程序 
 *  argc：argv数字个数，一般指传递给函数的参数数量
 *  argv：具体的参数内容，一般都是字符串格式
 *  return：0表示成功
 * 
*/
int main(int argc, char *argv[])
{
    int fd,ret;
    char *FileName;
    int cmd,arg;
    unsigned char str[100];
 
    /* 判断使用命令参数是否正确 */
    if(argc != 2){
        printf("命令使用错误!\r\n");
        ret = -1;
        goto fail_open;
    }
 
    /* 打开程序 */
    FileName = argv[1];
    fd = open(FileName,O_RDWR);
    if(fd < 0){
        printf("应用程序打开设备文件失败!\r\n");
        ret = fd;
        goto fail_open;
    }
 
    
    while(1) {
        printf("Please input CMD:");
        ret = scanf("%d",&cmd);
        if(ret != 1) {
            gets(str);
        }
 
        if(cmd == 1) {
            ret = ioctl(fd, OPEN_CMD, &arg);
        } else if(cmd == 2) {
            ret = ioctl(fd, CLOSE_CMD, &arg);
        } else if(cmd == 3) {
            printf("Input period:");
            ret = scanf("%d",&arg);
            if(ret != 1) { 
                gets(str);
            }
            ret = ioctl(fd, SET_PERIOD_CMD, &arg);
        }
    }
 
    /* 关闭文件 */
    close(fd);
    return 0;
 
fail_open:
    return ret;
}

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：/a/891599.html

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

7万字Java后端面试题大全（附答案）——持续更新

7万字Java后端面试题大全（附答案）——持续更新

目录 Java基础JDK/JRE/JVM三者的关系JDK常用的包 和 equals 的区别是什么&#xff1f;Java 中的几种基本数据类型了解么&#xff1f;什么是自动拆装箱&#xff1f;final 关键字中有什么作用&#xff1f;接口和抽象类有什么区别&#xff1f;String, StringBuffer 和 StringBuild…
阅读更多...
构建流媒体管道：利用 Docker 部署 Nginx-RTMP 从 FFmpeg RTMP 推流到 HLS 播放的完整流程

构建流媒体管道：利用 Docker 部署 Nginx-RTMP 从 FFmpeg RTMP 推流到 HLS 播放的完整流程

最近要实现一个类似导播台的功能&#xff0c;于是我先用 FFmpeg 实现一个参考对照的 Demo&#xff0c;我将其整理为一篇文章&#xff0c;方便后续大家或者和自己参考&#xff01; 1、软件工具介绍 本次部署相关软件 / 工具如下&#xff1a; FFmpeg&#xff1a;全称是 Fast Fo…
阅读更多...
与ZoomEye功能类似的搜索引擎还有哪些？（渗透课作业）

与ZoomEye功能类似的搜索引擎还有哪些？（渗透课作业）

与ZoomEye功能类似的搜索引擎有&#xff1a; Shodan&#xff1a;被誉为“物联网的搜索引擎”&#xff0c;专注于扫描和索引连接到互联网的各种设备&#xff0c;如智能家居设备、工业控制系统、摄像头、数据库等。它提供全球互联网设备的可视化视图&#xff0c;帮助用户了解网络…
阅读更多...
第21~22周Java主流框架入门-Spring 1SpringIoc容器与Bean管理

第21~22周Java主流框架入门-Spring 1SpringIoc容器与Bean管理

1.Spring IOC 与依赖注入课程笔记 课程简介 本节课介绍了 Spring 框架中的核心概念——IOC&#xff08;控制反转&#xff09;和 DI&#xff08;依赖注入&#xff09;。Spring 是 Java 生态中最重要的框架之一&#xff0c;几乎所有的 Java 项目开发都会使用它。理解 Spring 的…
阅读更多...
RWKV-CHN模型部署教程

RWKV-CHN模型部署教程

一、模型介绍 RWKV 语言模型&#xff08;用纯 100%RNN 达到 GPT 能力&#xff0c;甚至更强&#xff09;&#xff0c;该项目旨在通过为您自动化所有事情来消除使用大型语言模型的障碍。您需要的是一个只有几兆字节的轻量级可执行程序。此外&#xff0c;该项目还提供了一个接口兼…
阅读更多...
python yolov8半自动标注

python yolov8半自动标注

首先标注一部分图片&#xff0c;进行训练&#xff0c;生成模型&#xff0c;标注文件为xml方便后面统一做处理。 1、标注数据&#xff08;文件为xml, 转为txt用于训练&#xff0c;保留xml标签文件&#xff09; 2、模型训练&#xff08;训练配置、训练代码、&#xff09; 3、使用…
阅读更多...
一个将.Geojson文件转成shapefile和kml文件的在线页面工具

一个将.Geojson文件转成shapefile和kml文件的在线页面工具

最近需要读取.geojson格式的流域边界文件。在谷歌地球桌面版和globalMapper中均无法正常读取。下面我发现的一个在线的平台可以很好实现这一功能。 GeoJSON to SHP Converter Online - MyGeodata Cloud ❤️欢迎点赞收藏❤️
阅读更多...
关于WPF（Windows Presentation Foundation）中Grid控件

关于WPF（Windows Presentation Foundation）中Grid控件

本文将从Grid控件的基础概念开始&#xff0c;逐步深入探讨其特性、用法、实例代码&#xff0c;以及最佳实践。 1. WPF和布局简介 WPF是一种用于构建Windows桌面应用程序的UI框架&#xff0c;它通过XAML&#xff08;Extensible Application Markup Language&#xff09;使开…
阅读更多...
Oracle中解决select into值集为空的报错情况

Oracle中解决select into值集为空的报错情况

先看为空的情况 procedure test is n number; begin select 1 into n from CUX_2_OM_RELEASE_LIMIT_V cov where cov.Customer_Idnull; end; CUX_2_OM_RELEASE_LIMIT_V中没有id是空的&#xff0c;因此返回的结果一定是空集 运行结果: 有时候我…
阅读更多...
QT事件与网络通信

QT事件与网络通信

闹钟 头文件 #ifndef MAINWINDOW_H #define MAINWINDOW_H#include <QMainWindow> #include <QTimer> #include <QTextToSpeech> // 添加此行以引入QTextToSpeech类QT_BEGIN_NAMESPACE namespace Ui { class MainWindow; } QT_END_NAMESPACEclass MainWin…
阅读更多...
大数据ETL数据提取转换和加载处理

大数据ETL数据提取转换和加载处理

什么是 ETL&#xff1f; 提取转换加载&#xff08;英语&#xff1a;Extract, transform, load&#xff0c;简称ETL&#xff09;&#xff0c;用来描述将资料从来源端经过抽取、转置、加载至目的端的过程。ETL一词较常用在数据仓库&#xff0c;但其对象并不限于数据仓库。 ETL&…
阅读更多...
下载Edge/Chrome浏览器主题的背景图片

下载Edge/Chrome浏览器主题的背景图片

当我们为Edge安装了心仪的主题后&#xff0c;希望把对应的背景图片下载保存要怎么做呢&#xff0c;以下图的“湖心小屋”主题为例。如下图&#xff0c;我们已经在应用商店中按照了该主题。 当打开新标签页后&#xff0c;可以欣赏这个主题内置的背景图片。 如果想要下载这个背景…
阅读更多...
【人工智能/计算机工程/大数据】第五届人工智能与计算工程国际学术会议（ICAICE 2024，2024年11月8-10日）

【人工智能/计算机工程/大数据】第五届人工智能与计算工程国际学术会议（ICAICE 2024，2024年11月8-10日）

The 5th International Conference on Artificial Intelligence and Computer Engineering 第五届人工智能与计算工程国际学术会议&#xff08;ICAICE 2024&#xff09; 会议官网&#xff1a;www.event-icaice.org The 5th International Conference on Artificial Intellige…
阅读更多...
外包干了5天，技术明显退步

外包干了5天，技术明显退步

我是一名本科生&#xff0c;自2019年起&#xff0c;我便在南京某软件公司担任功能测试的工作。这份工作虽然稳定&#xff0c;但日复一日的重复性工作让我逐渐陷入了舒适区&#xff0c;失去了前进的动力。两年的时光匆匆流逝&#xff0c;我却在原地踏步&#xff0c;技术没有丝毫…
阅读更多...
【Vue】Vue扫盲（二）指令：v-for 、v-if、v-else-if、v-else、v-show

【Vue】Vue扫盲（二）指令：v-for 、v-if、v-else-if、v-else、v-show

【Vue】Vue扫盲&#xff08;一&#xff09;事件标签、事件修饰符&#xff1a;click.prevent click.stop click.stop.prevent、按键修饰符、及常用指令 文章目录 一、v-for遍历数组数组角标遍历对象&#xff1a;Key作用介绍 二、v-if、v-show基本用法&#xff1a;案例&#xff1…
阅读更多...
Linux--多路转接之epoll

Linux--多路转接之epoll

上一篇:Linux–多路转接之select epoll epoll 是 Linux 下多路复用 I/O 接口 select/poll 的增强版本&#xff0c;它能显著提高程序在大量并发连接中只有少量活跃的情况下的系统 CPU 利用率。它是 Linux 下多路复用 API 的一个选择&#xff0c;相比 select 和 poll&#xff0c…
阅读更多...
用于病理图像诊断的跨尺度多实例学习|文献速递-基于深度学习的医学影像分类，分割与多模态应用

用于病理图像诊断的跨尺度多实例学习|文献速递-基于深度学习的医学影像分类，分割与多模态应用

Title 题目 Cross-scale multi-instance learning for pathological image diagnosis 用于病理图像诊断的跨尺度多实例学习 01 文献速递介绍 病理学是诊断炎症性肠病&#xff08;如克罗恩病&#xff09;的金标准&#xff08;Gubatan等&#xff0c;2021&#xff1b;Yeshi等…
阅读更多...
机器学习：opencv--人脸检测以及微笑检测

机器学习：opencv--人脸检测以及微笑检测

目录 前言 一、人脸检测的原理 1.特征提取 2.分类器 二、代码实现 1.图片预处理 2.加载分类器 3.进行人脸识别 4.标注人脸及显示 三、微笑检测 前言 人脸检测是计算机视觉中的一个重要任务&#xff0c;旨在自动识别图像或视频中的人脸。它可以用于多种应用&#xff0…
阅读更多...
Vxe UI vue vxe-table select 下拉框选项列表数据量超大过大时卡顿解决方法

Vxe UI vue vxe-table select 下拉框选项列表数据量超大过大时卡顿解决方法

Vxe UI vue vxe-table vxe-grid select 下拉框选项列表数据量超大过大时卡顿解决方法 查看 github vxe-table 官网 vxe-table 本身支持虚拟滚动&#xff0c;数据量大也是支持的&#xff0c;但是如果在可编辑表格中使用下拉框&#xff0c;下拉框的数据量超大时&#xff0c;可能…
阅读更多...
int QSqlQuery::size() const

int QSqlQuery::size() const

返回结果的大小&#xff08;返回的行数&#xff09; 或者返回-1 &#xff08;如果大小不能被决定 或者 数据库不支持报告查询的大小信息&#xff09; 注意&#xff1a;对于非查询语句&#xff0c;将返回-1&#xff08;isSelect()返回false&#xff09; 如果查询不是活跃的&…
阅读更多...
最新文章

Copyright @ 2022~2023