linux下精密定时器

最新推荐文章于 2024-04-29 21:58:18 发布
最新推荐文章于 2024-04-29 21:58:18 发布
阅读量844 收藏 1
点赞数
分类专栏： linux系统开发 C语言 文章标签： linux timer struct null linux内核 signal

转自：http://blog.163.com/hong_nt/blog/static/10468917120081130103632925/


软件定时器的主要功能是实现状态机的超时机制和实现基于超时的计数功能。
由于协议状态机运行于Linux内核之上，也就是说在用户态运行。在 Linux系统中，用户态应用程序只能调用三个定时器：ITIMER_REAL、ITIMER_VIRTUAL和ITIMER_PROF。而在协议状态机 中需要32个定时器，所以需要新的机制来完成定时功能。
软件定时器主要被用来解决硬件定时器的物理限制，并为应用程序提供更加灵活的定时器编程接 口。定时器最基本的作用就是允许某个任务在将来某个特定时间点运行。定时器超时，被注册的任务开始运行，在我们的系统中，和定时器相关的任务就是产生某个 定时器超时事件。我们定义最基本的定时器结构Timer，当作我们的软件定时器对象：
#define MAX_TIMERS N  //N为你需要的定时器的个数
struct Timer{
                long timeout;                        // 定时器超时时间，单位毫秒ms
                long expire;                        // 下一次中断时定时器剩余的超时时间，单位毫秒ms
                int inuse;                        // 定时器是否被使用
                int set;                                // 定时器是否超时
                int signal;                        // 定时器超时时，发送的事件类型
                int param;                        // 定时器超时时，发送的事件类型的参数
}T[MAX_TIMERS];// 定时器集合
        软件定时器提供给应用程序的接口主要有4个：
        Int init_timers();                                // 初始化定时器集合
        Int start_timer(struct Timer *T);        // 启动定时器T
        Int stop_timer(struct Timer *T);        // 停止定时器T
        Int get_event();                                // 查询超时的定时器事件
程序初始化时调用init_timers()初始化定时器集合，初始化之后就可以在系统中调用start_timer()和stop_timer()来使用定时器功能。协议状态机循环调用get_event()查询超时的定时器事件，输入到协议状态机内部。
软 件定时器基于一个内部的由Linux操作系统提供的定时器ITIMER_REAL，实际的定时工作都由该定时器完成。定时器ITIMER_REAL每次超 时时，调用update_timers()更新定时器集合，将超时的定时器的set位置位，并查询定时器集合中所有已经启动的定时器，选择expire值 最小的那个定时器，用该expire值来重置定时器ITIMER_REAL，并更新定时器集合中所有已启动定时器的expire值。也就是说在该 expire毫秒后，定时器ITIMER_REAL将重新发生超时中断，重复以上过程。如果没有软件定时器被启动，定时器ITIMER_REAL将被清 零，直到下一次调用start_timer()。
如果在两次中断之间调用start_timer(struct Timer *T)，将会比较T->expire值和离下一次时钟中断的时间间隔time_remain。如果T->expire小于 time_remain，则将把T作为最小定时器，用T->expire重置内部定时器ITIMER_REAL，并更新定时器集合中所有已启动定时 器的expire值；如果T->expire不小于time_remain，则只需更新T的expire值。
stop_timer(struct Timer *T)只需将T的使用标识位insue置零，在更新定时器集合时就会被自动忽略。

部分代码如下：
程序soft_timer.c:

#include "soft_timer.h"
int delta = 10;
long start = 0;
struct itimerval phy_timer;
struct itimerval old_timer;
struct Timer *cur_timer;

void update_timers(int sig)
{
        int i = 0;
        int min_timer = -1;
        long min_expire = 1000000000;

        if(cur_timer->inuse)cur_timer->set = 1;

        for(i=0; i<MAX_TIMERS; i++){
                if(T.inuse && !T.set){
                        if(T.expire<delta){
                                T.set = 1;
                        }else if(T.expire > 0 && min_expire>T.expire){
                                min_expire = T.expire;
                                min_timer = i;
                        }
                }
        }

        if(min_timer<0){
                timerclear(&(phy_timer.it_value));
                timerclear(&(phy_timer.it_interval));
        }else{
                phy_timer.it_value.tv_sec = min_expire/1000;
                phy_timer.it_value.tv_usec = (min_expire%1000)*1000;
                timerclear(&(phy_timer.it_interval));
                cur_timer = &T[min_timer];
                for(i=0; i<MAX_TIMERS; i++){
                        if(T.inuse && !T.set){
                                T.expire -= min_expire;
                        }
                }
        }

        setitimer(ITIMER_REAL, &phy_timer, NULL);
}

int create_phy_timer(struct itimerval *timer, void (*handler)(int))
{
int rc = 0;
        struct sigaction sa;
        memset (&sa, 0, sizeof (sa));
        sa.sa_handler = handler;
        sigaction(SIGALRM, &sa, NULL);

        timerclear(&(timer->it_value));
        timerclear(&(timer->it_interval));
        
        setitimer(ITIMER_REAL, timer, NULL);

        return rc;

}

int init_timers()
{
int ret = 0;
        int i = 0;
        for(i=0;i<MAX_TIMERS;i++){
                T.inuse = 0;
                T.param = 0;
                T.set = 0;
                T.timeout = 0;
                T.expire = 0;
        }
    cur_timer = &T[0];
        create_phy_timer(&phy_timer, update_timers);
}

int start_timer(struct Timer *t)
{
int ret = 0;
        int i = 0;
        long diff = 0;
        long time_remain;

        t->expire = t->timeout;
        t->inuse = 1;
        t->set = 0;
        getitimer(ITIMER_REAL, &old_timer);

        time_remain = old_timer.it_value.tv_sec*1000+old_timer.it_value.tv_usec/1000;
        //printf("time_remain=%ld/n",time_remain);
        if(time_remain==0){
               
                phy_timer.it_value.tv_sec = t->timeout/1000;
                phy_timer.it_value.tv_usec = (t->timeout%1000)*1000;
                timerclear(&(phy_timer.it_interval));
                setitimer(ITIMER_REAL, &phy_timer, NULL);
                cur_timer = t;
                return ret;
        }
        
        if(t->timeout+delta<=time_remain){
                diff = time_remain - t->timeout;

                for(i=0; i<MAX_TIMERS; i++){
                        
                        if(cur_timer==&T){
                                cur_timer->expire = diff;
                        }else if(t==&T){
                        }else if(T.inuse && !T.set){
                                T.expire +=  diff;
                        }
                }

                phy_timer.it_value.tv_sec = t->timeout/1000;
                phy_timer.it_value.tv_usec = (t->timeout%1000)*1000;
                timerclear(&(phy_timer.it_interval));
                setitimer(ITIMER_REAL, &phy_timer, NULL);
                cur_timer = t;

                }else{
                        t->expire = t->timeout - time_remain;
                        //printf("t->expire =%ld/n", t->expire);
                }
        return ret;
        
}
int stop_timer(struct Timer *t)
{
        int ret = 0;
        t->inuse = 0;
        t->expire = t->timeout;
        t->set = 0;
        return ret;
        
}
long current_millis()
{
        struct timeval tv;
        long  now;
        gettimeofday(&tv, NULL);
        now = (tv.tv_sec%100000)*1000+tv.tv_usec/1000;
        return now;
}

void sleep_millis(long ms)
{
        struct timespec tv;
        tv.tv_sec = ms/1000;
        tv.tv_nsec = (long)(ms%1000)*1000000;

        nanosleep(&tv, NULL);
}




soft_timer.h头文件如下：

#define MAX_TIMERS N

struct Timer{
        long timeout;
        long expire;
        int inuse;
        int set;
        int signal;
        int param;
}T[MAX_TIMERS];


extern int init_timers();
extern int start_timer(struct Timer *t);
extern int stop_timer(struct Timer *t);
extern int start_phy_timer(struct Timer *t, void (*handler)(int));
extern int stop_phy_timer(struct Timer *t);

extern long current_millis();
extern void sleep_millis(long ms);

#ifdef __cplusplus
}
#endif

#endif /*__soft_timer_h*/



在调用的时候可以先将其初始化
        init_timers();
        for(i = 1; i< MAX_TIMERS; i++){
                if(i<N_TIMERS){
                        T.timeout = timeouts;
                        T.signal = time_events;
                }else{
                        T.timeout = T[13].timeout;
                        T.signal = T[13].signal;
                }
        }



随后在适当的时刻start_timer(&T[n])；或者stop_timer(&T[n])；就可以了

cnctloveyu
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Linux下实现定时器Timer的几种方法总结
09-15
下面小编就为大家带来一篇Linux下实现定时器Timer的几种方法总结。小编觉得挺不错的，现在就分享给大家，也给大家做个参考。一起跟随小编过来看看吧
linux 内核定时器 timer_list详解
热门推荐
qingkongyeyue的博客
07-10 1万+
转自http://www.cnblogs.com/leaven/archive/2010/08/19/1803382.html Linux内核2.4版中去掉了老版本内核中的静态定时器机制，而只留下动态定时器。相应地在timer_bh()函数中也不再通 过run_old_timers()函数来运行老式的静态定时器。动态定时器与静态定时器这二个概念是相对于Linux内核定时器机 制的
linux用户态定时器,linux下精密定时器
weixin_28978471的博客
04-29 405
在linux下的精密定时器软件定时器的主要功能是实现状态机的超时机制和实现基于超时的计数功能。由于协议状态机运行于Linux内核之上，也就是说在用户态运行。在Linux系统中，用户态应用程序只能调用三个定时器：ITIMER_REAL、 ITIMER_VIRTUAL和ITIMER_PROF。而在协议状态机中需要32个定时器，所以需要新的机制来完成定时功能。软件定时器主要被用来解决硬件定时器的物理限制...
Linux高精度定时器
12-13 1394
一、检查高分辨率计时器是否可用 在/boot目录中，检查内核配置文件。它应该有一行类似CONFIG_HIGH_RES_TIMERS=y。 检查/proc/timer_list的内容。 使用clock_getres系统调用获取时钟分辨率。 二、高分辨率计时器的用户 精密计时器的主要用户是利用纳米睡眠、posix-timers和间隔计时器（itimer）接口的用户空间应用程序。 在内核中，驱动程序和子系统等用户需要精确定时的事件（例如多媒体）。 三、High Resolution timer 核心数据
Linux下C语言 定时器
09-23
linux 下使用红黑树实现的多线程定时器， 定时回调对应的回调函数，定时单位为毫秒。
Linux下实时定时器的实现及应用.PDF
08-24
Linux下实时定时器的实现及应用.PDF
Linux的动态定时器-时间轮
01-09
定时器—有时也称为动态定时器或内核...要想完全弄清楚linux2.6中内核定时器的实现，得先从初始化开始。 　在start_kernel(void)–>init_timers(void) void __init init_timers(void) { int err = timer_cpu_n
linux下多定时器+线程池的实现（经典）
01-11
//linux只允许单进程拥有一个定时器，因此在linux下的单进程中要使用多个定时器，则需要自己维护管理 // //这个实现允许用户使用多个自定义的定时器，每个自定义的定时器将周期地被触发直到其被删除。实现的主要思路...
13 Linux实操篇-网络配置
qq_74289024的博客
04-23 1044
子网ip 与网关。
Linux多进程(五) 进程池 C++实现
Lyajpunov的博客
04-26 797
进程池是一种并发编程模式，用于管理和重用多个处理任务的进程。它通常用于需要频繁创建和销毁进程的情况，以避免因此产生的开销。减少进程创建销毁的开销：避免频繁创建和销毁进程所带来的系统资源开销。提高系统响应速度：由于进程已经初始化并且一直保持在内存中，可以立即分配执行任务，减少了任务等待时间。控制资源使用：通过限制进程池中的进程数量，可以控制系统资源的使用情况，避免资源过度消耗。
Linux——web服务配置
Xinan_____的博客
04-23 1130
GET：请求获取指定资源的表示形式。使用GET方法，客户端请求服务器发送某个资源。POST：向指定资源提交数据，用于处理表单提交、文件上传等操作。PUT：向指定资源位置上传其最新内容，用于更新资源。DELETE：请求服务器删除指定资源。HEAD：请求获取与实体相对应的头部信息，用于获取资源的元数据。OPTIONS：请求查询服务器支持的HTTP方法。TRACE：请求服务器回显收到的请求消息，用于测试或诊断。200 OK：请求成功。：永久重定向，请求的资源已经被分配了新的。
Linux：浏览器访问网站的基本流程（优先级从先到后）
fox_kang的博客
04-28 605
浏览器访问网站的基本流程（优先级从先到后） 首先查找浏览器是否存在该网站的访问缓存 其次查找本机的域名解析服务器 windows：C:\Windows\System32\drivers\etc\hosts Linux：/etc/hosts 使用外部的域名解析服务器解析（例如：114.114.114.114） 第一步：浏览器使用域名访问www.bilibili.com.网站 第二步：首先去访问根域名解析服务器查询，根服务器返回.com域名解析服务器地址==（这里的根域名解析服务器不会直接给出域名对应的
Linux 抽象命名空间（Abstract Namespace）简介
日拱一卒，玉汝于成
04-25 584
与传统的 UDS 不同，抽象命名空间并不在文件系统中创建实际文件，而是仅存在于内核内存中，其名称以 localabstract: 作为前缀。在这个例子中，我们创建了一个名为 my_abstract_namespace 的抽象命名空间，并将其绑定到了刚创建的 Unix 套接字上。要在 Linux 系统中生成一个抽象命名空间，通常需要使用编程语言的套接字 API 来创建一个 Unix 域套接字，并将其绑定到一个以 localabstract: 开头的特殊路径。
arm架构Linux5.0内核连接脚本文件vmlinux.lds.S分析
jianjian的博客
04-23 980
vmlinux.lds.S 是 Linux 内核中用于链接的脚本文件，用于定义内核对象文件的内存布局，即它告诉链接器如何将不同的内核代码段和数据段组合成一个最终的内核映像 vmlinux。编译内核源码生成内核文件的过程分两步，一个是“编译”，另一个是“链接”的过程，vmlinux.lds.S要做的就是告诉编译器如何链接编译好的各个内核.o文件，从而生成vmlinux文件。
linux的“＞”和“＞＞”
qq_45212655的博客
04-24 459
文件存在，新的输出将被添加到文件的内容之后；如果文件不存在，将会创建一个新文件。文件存在，它的内容将被新的输出覆盖；如果文件不存在，将会创建一个新文件。都是用于文件重定向的操作符，它们用于将命令的输出发送到文件中。用于创建一个新文件或覆盖现有文件的内容。用于将输出附加到现有文件的末尾，而不是覆盖它。
Linux中的YUM源仓库和NFS文件共享服务
最新发布
2402_83805984的博客
04-29 389
yum是一个基于RPM包（是Red-Hat Package Manager红帽软件包管理器的缩写）构建的软件更新机制，能够自动解决软件包之间的依赖关系=，解决了日常工作中的大量查找安装依赖包的时间。NFS是一种基于TCP/IP传输的网络文件系统协议，最初由sun公司开发，通过NFS协议。客户机可以向访问本地目录一样访问远程NFS服务器中的共享资源。NFS也是NAS存储设备必然支持的一种协议，但是因为没有用户认证机制，而且数据在网络上明文传输、安全性很差，所以一般只能在局域网中使用。
Linux--内核移植（二）移植流程及驱动修改
qq_47258284的博客
04-23 1057
一、官方开发板内核测试本文来总结一下如何将 NXP官方提供的Linux内核移植到正点原子的开发板上。一、官方开发板内核测试NXP提供的Linux源码肯定是可以在自己的开发板上运行下去的，所以我们肯定是以 I.MX6ULL EVK开发板为参考，然后将Linux内核移植到开发板上的。1.修改顶层Makefile修改顶层Makefile，直接在顶层Makefile文件里面定义ARCH和这两个的变量值为 arm和 arm-linux-gnueabihf-。
Linux系统编程--信号与管道
qq_53344001的博客
04-28 1014
open 函数在打开管道文件的时候，必须两方都执行 open，open 才能打开，只有一个进程执行 open，open 会发生阻塞，直到另外的一个进程也运行到 open 的位置，两方同时解除阻塞。内核：当我们的程序出现一些错误的时候，例如段错误等，内核会给我们的进程发送杀死当前进程的信号。这就是通信机制：信号、管道。14 -- SIGALRM -- 闹钟信号，杀死进程。设置闹钟，闹钟事件到，产生闹钟信号，闹钟信号默认杀死当前进程；如果上一次设置的有闹钟，返回上一个闹钟的剩余时间，否则返回 0；
Linux下实现定时器
05-18
在Linux中，有几种方法可以实现定时器功能： 1. 使用系统调用 alarm()：该调用会在指定的时间（以秒为单位）后触发SIGALRM信号。可以通过注册信号处理函数来处理该信号，实现定时器功能。例如： ``` #include <unistd.h> #include <signal.h> void handler(int signum) { // 定时器触发后的处理逻辑 } int main() { signal(SIGALRM, handler); alarm(5); // 5秒后触发SIGALRM信号 while (1) {} // 持续运行程序，直到收到SIGALRM信号 return 0; } ``` 2. 使用timer_create()函数：该函数可以创建一个定时器，精度可以达到毫秒级别。例如： ``` #include <time.h> #include <signal.h> void handler(int signum) { // 定时器触发后的处理逻辑 } int main() { struct sigevent sev; timer_t timerid; struct itimerspec its; // 创建定时器 sev.sigev_notify = SIGEV_SIGNAL; sev.sigev_signo = SIGUSR1; sev.sigev_value.sival_ptr = &timerid; timer_create(CLOCK_REALTIME, &sev, &timerid); // 设置定时器 its.it_value.tv_sec = 1; its.it_value.tv_nsec = 0; its.it_interval.tv_sec = 1; its.it_interval.tv_nsec = 0; timer_settime(timerid, 0, &its, NULL); // 注册信号处理函数 signal(SIGUSR1, handler); while (1) {} // 持续运行程序，直到收到SIGUSR1信号 return 0; } ``` 3. 使用select()函数：该函数可以等待多个文件描述符中的任意一个就绪，可以通过设置超时时间实现定时器功能。例如： ``` #include <stdio.h> #include <sys/select.h> int main() { fd_set rfds; struct timeval tv; while (1) { // 清空文件描述符集合 FD_ZERO(&rfds); // 设置需要监视的文件描述符 FD_SET(0, &rfds); // 监视标准输入 // 设置超时时间 tv.tv_sec = 5; tv.tv_usec = 0; // 等待文件描述符就绪或超时 int ret = select(1, &rfds, NULL, NULL, &tv); if (ret == -1) { perror("select"); } else if (ret == 0) { printf("Timeout\n"); // 超时处理逻辑 } else { if (FD_ISSET(0, &rfds)) { printf("Input available\n"); // 文件描述符就绪处理逻辑 } } } return 0; } ``` 这些方法都可以实现定时器功能，选择哪种方法取决于具体的场景和需求。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值