linux定时器编程

① linux下多个定时器的实现（C语言），麻烦高手指点哈嘛（急）

给你两个函数参考
omsTimer函数是处理定时事件，void(*handle)(union sigval v)参数就是处理事件的函数指针。
int omsSetTimer(timer_t *tId,int value,int interval)就是设置定时器。
按你说的，如果要同时起多个定时器，需要定义一个数组timer_t tm[n];int it[n];tm就是定时器结构，it用来记录对应的定时器是否已经使用，使用中的就是1，没用的就是0；
主进程消息来了就从it找一个没用的来omsSetTimer，如果收到终止消息，那omsSetTimer 定时时间为0
int omsTimer(timer_t *tId,int iValue,int iSeconds ,void(*handle)(union sigval v),void * param)
{
struct sigevent se;
struct itimerspec ts;
memset (&se, 0, sizeof (se));
se.sigev_notify = SIGEV_THREAD;
se.sigev_notify_function = handle;
se.sigev_value.sival_ptr = param;
if (timer_create (CLOCK_REALTIME, &se, tId) < 0)
{
return -1;
}
ts.it_value.tv_sec = iValue;
// ts.it_value.tv_sec =3;
//ts.it_value.tv_nsec = (long)(iValue % 1000) * (1000000L);
ts.it_value.tv_nsec = 0;
ts.it_interval.tv_sec = iSeconds;
//ts.it_interval.tv_nsec = (long)(iSeconds % 1000) * (1000000L);
ts.it_interval.tv_nsec = 0;
if (timer_settime(*tId, TIMER_ABSTIME, &ts, NULL) < 0)
{
return -1;
}
return 0;
}
int omsSetTimer(timer_t *tId,int value,int interval)
{
struct itimerspec ts;
ts.it_value.tv_sec =value;
//ts.it_value.tv_nsec = (long)(value % 1000) * (1000000L);
ts.it_value.tv_nsec = 0;
ts.it_interval.tv_sec = interval;
//ts.it_interval.tv_nsec = (long)(interval % 1000) * (1000000L);
ts.it_interval.tv_nsec = 0;
if (timer_settime(*tId, TIMER_ABSTIME, &ts, NULL) < 0)
{
return -1;
}
return 0;
}

② linux下C语言定时器(求高人指点)

可以用alarm信号做：

alarm（设置信号传送闹钟）
相关函数 signal，sleep

表头文件 #include<unistd.h>

定义函数 unsigned int alarm(unsigned int seconds);

函数说明 alarm()用来设置信号SIGALRM在经过参数seconds指定的秒数后传送给目前的进程。如果参数seconds 为0，则之前设置的闹钟会被取消，并将剩下的时间返回。

返回值返回之前闹钟的剩余秒数，如果之前未设闹钟则返回0。

#include<unistd.h>
#include<signal.h>
void handler() {
//这里读跳变次数
}
main()
{
int i;
signal(SIGALRM,handler);//这里设置时钟信号的响应函数
alarm(1); //这里设置每一秒钟发送一个时钟信号
}

③ 求linux下用c语言编写的定时器程序

//一个示例程序。
#include<stdlib.h>
#include<unistd.h>
#include<signal.h>
#include<time.h>
#include<sys/time.h>
#defineN100//设置最大的定时器个数
inti=0,t=1;//i代表定时器的个数；t表示时间，逐秒递增

structTimer//Timer结构体，用来保存一个定时器的信息
{
inttotal_time;//每隔total_time秒
intleft_time;//还剩left_time秒
intfunc;//该定时器超时，要执行的代码的标志
}myTimer[N];//定义Timer类型的数组，用来保存所有的定时器

voidsetTimer(intt,intf)//新建一个计时器
{
structTimera;
a.total_time=t;
a.left_time=t;
a.func=f;
myTimer[i++]=a;
}

voidtimeout()//判断定时器是否超时，以及超时时所要执行的动作
{
printf("Time:%d
",t++);
intj;
for(j=0;j<i;j++)
{
if(myTimer[j].left_time!=0)
myTimer[j].left_time--;
else
{
switch(myTimer[j].func)
{//通过匹配myTimer[j].func，判断下一步选择哪种操作
case1:
printf("------Timer1:--HelloAillo!
");break;
case2:
printf("------Timer2:--HelloJackie!
");break;
case3:
printf("------Timer3:--HelloPiPi!
");break;
}
myTimer[j].left_time=myTimer[j].total_time;//循环计时
}
}
}

intmain()//测试函数，定义三个定时器
{
setTimer(3,1);
setTimer(4,2);
setTimer(5,3);
signal(SIGALRM,timeout);//接到SIGALRM信号，则执行timeout函数

while(1)
{
sleep(1);//每隔一秒发送一个SIGALRM
kill(getpid(),SIGALRM);
}
exit(0);
}

④ 在linux C编程中，定时器函数选择与设置问题

试试alarm()与signal()，例子可以网上搜搜

NAME
alarm - set an alarm clock for delivery of a signal

SYNOPSIS
#include <unistd.h>

unsigned int alarm(unsigned int seconds);

DESCRIPTION
alarm() arranges for a SIGALRM signal to be delivered to the calling process in seconds seconds.

If seconds is zero, no new alarm() is scheled.

In any event any previously set alarm() is canceled.

⑤ Linux中断与定时器

所谓中断是指CPU在执行程序的过程中，出现了某些突发事件急待处理，CPU必须暂停当前程序的执行，转去处理突发事件，处理完毕后又返回原程序被中断的位置继续执行。根据中断的来源，中断可分为内部中断和外部中断，内部中断的中断源来自CPU内部（软件中断指令、溢出、除法错误等，例如，操作系统从用户态切换到内核态需借助CPU内部的软件中断），外部中断的中断源来自CPU外部，由外设提出请求。根据中断是否可以屏蔽，中断可分为可屏蔽中断与不可屏蔽中断（NMI），可屏蔽中断可以通过设置中断控制器寄存器等方法被屏蔽，屏蔽后，该中断不再得到响应，而不可屏蔽中断不能被屏蔽。
根据中断入口跳转方法的不同，中断可分为向量中断和非向量中断。采用向量中断的CPU通常为不同的中断分配不同的中断号，当检测到某中断号的中断到来后，就自动跳转到与该中断号对应的地址执行。不同中断号的中断有不同的入口地址。非向量中断的多个中断共享一个入口地址，进入该入口地址后，再通过软件判断中断标志来识别具体是哪个中断。也就是说，向量中断由硬件提供中断服务程序入口地址，非向量中断由软件提供中断服务程序入口地址。
嵌入式系统以及x86PC中大多包含可编程中断控制器（PIC），许多MCU内部就集成了PIC。如在80386中，PIC是两片i8259A芯片的级联。通过读写PIC的寄存器，程序员可以屏蔽/使能某中断及获得中断状态，前者一般通过中断MASK寄存器完成，后者一般通过中断PEND寄存器完成。定时器在硬件上也依赖中断来实现，典型的嵌入式微处理器内可编程间隔定时器（PIT）的工作原理，它接收一个时钟输入，当时钟脉冲到来时，将目前计数值增1并与预先设置的计数值（计数目标）比较，若相等，证明计数周期满，并产生定时器中断且复位目前计数值。

⑥ linux下的几种时钟和定时器机制

1. RTC(Real Time Clock)

所有PC都有RTC. 它和CPU和其他芯片独立。它在电脑关机之后还可以正常运行。RTC可以在IRQ8上产生周期性中断. 频率在2Hz--8192HZ.

Linux只是把RTC用来获取时间和日期. 当然它允许进程通过对/dev/rtc设备来对它进行编程。Kernel通过0x70和0x71 I/O端口来访问RTC。

 

2. TSC(Time Stamp Counter)

80x86上的微处理器都有CLK输入针脚. 从奔腾系列开始. 微处理器支持一个计数器. 每当一个时钟信号来的时候. 计数器加1. 可以通过汇编指令rdtsc来得到计数器的值。通过calibrate_tsc可以获得CPU的频率. 它是通过计算大约5毫秒里tsc寄存器里面的增加值来确认的。或者可以通过cat /proc/cpuinfo来获取cpu频率。tsc可以提供比PIT更精确的时间度量。

 

3. PIT(Programmable internval timer)

除了RTC和TSC. IBM兼容机提供了PIT。PIT类似微波炉的闹钟机制. 当时间到的时候. 提供铃声. PIT不是产生铃声. 而是产生一种特殊中断. 叫定时器中断或者时钟中断。它用来告诉内核一个间隔过去了。这个时间间隔也叫做一个滴答数。可以通过编译内核是选择内核频率来确定。如内核频率设为1000HZ,则时间间隔或滴答为1/1000=1微秒。滴答月短. 定时精度更高. 但是用户模式的时间更短. 也就是说用户模式下程序执行会越慢。滴答的长度以纳秒形式存在tick_nsec变量里面。PIT通过8254的0x40--0x43端口来访问。它产生中断号为IRQ 0.

下面是关于pIT里面的一些宏定义：

HZ：每秒中断数。

CLOCK_TICK_RATE:值是1,193,182. 它是8254芯片内部振荡器频率。

LATCH：代表CLOCK_TICK_RATE和HZ的比率. 被用来编程PIT。

setup_pit_timer()如下：

spin_lock_irqsave(&i8253_lock, flags);

outb_p(0x34,0x43);

udelay(10);

outb_p(LATCH & 0xff, 0x40);

udelay(10);

outb (LATCH >> 8, 0x40);

spin_unlock_irqrestore(&i8253_lock, flags);

 

 

4. CPU Local Timer

最近的80x86架构的微处理器上的local apic提供了cpu local timer.他和pit区别在于它提供了one-shot和periodic中断。它可以使中断发送到特定cpu。one-shot中断常用在实时系统里面。

⑦ 怎样在Linux下实现精确定时器

linux下使用select实现精确定时器
在编写程序时，我们经常回用到定时器。本文讲述如何使用select实现超级时钟。使用select函数，我们能实现微妙级别精度的定时器。同时，select函数也是我们在编写非阻塞程序时经常用到的一个函数。
首先看看select函数原型如下：
int select(int nfds, fd_set *readfds, fd_set *writefds,
fd_set *exceptfds, struct timeval *timeout);

参数说明：
slect的第一个参数nfds为fdset集合中最大描述符值加1，fdset是一个位数组，其大小限制为__FD_SETSIZE（1024），位数组的每一位代表其对应的描述符是否需要被检查。
select的第二三四个参数表示需要关注读、写、错误事件的文件描述符位数组，这些参数既是输入参数也是输出参数，可能会被内核修改用于标示哪些描述符上发生了关注的事件。所以每次调用select前都需重新初始化fdset。
timeout参数为超时时间，该结构会被内核修改，其值为超时剩余的时间。
利用select实现定时器，需要利用其timeout参数,注意到：
1）select函数使用了一个结构体timeval作为其参数。
2）select函数会更新timeval的值，timeval保持的值为剩余时间。
如果我们指定了参数timeval的值，而将其他参数都置为0或者NULL，那么在时间耗尽后，select函数便返回，基于这一点，我们可以利用select实现精确定时。
timeval的结构如下：
struct timeval{
long tv_sec；/*secons*
long tv_usec;/*microseconds*/
}

我们可以看出其精确到microseconds也即微妙。
一、秒级定时器

void seconds_sleep(unsigned seconds){
struct timeval tv;
tv.tv_sec=seconds;
tv.tv_usec=0;
int err;
do{
err=select(0,NULL,NULL,NULL,&tv);
}while(err<0 && errno==EINTR);
}

二、毫秒级别定时器

void milliseconds_sleep(unsigned long mSec){
struct timeval tv;
tv.tv_sec=mSec/1000;
tv.tv_usec=(mSec%1000)*1000;
int err;
do{
err=select(0,NULL,NULL,NULL,&tv);
}while(err<0 && errno==EINTR);
}

三、微妙级别定时器

void microseconds_sleep(unsigned long uSec){
struct timeval tv;
tv.tv_sec=uSec/1000000;
tv.tv_usec=uSec%1000000;
int err;
do{
err=select(0,NULL,NULL,NULL,&tv);
}while(err<0 && errno==EINTR);
}

现在我们来编写几行代码看看定时效果吧。

#include <stdio.h>
#include <sys/time.h>
#include <errno.h>
int main()
{
int i;
for(i=0;i<5;++i){
printf("%d\n",i);
//seconds_sleep(1);
//milliseconds_sleep(1500);
microseconds_sleep(1900000);
}
}

注：timeval结构体中虽然指定了一个微妙级别的分辨率，但内核支持的分别率往往没有这么高，很多unix内核将超时值向上舍入成10ms的倍数。此外，加上内核调度延时现象，即定时器时间到后，内核还需要花一定时间调度相应进程的运行。因此，定时器的精度，最终还是由内核支持的分别率决定。