linux timer

最新推荐文章于 2024-07-12 16:34:36 发布

hhwyqwqhhwy

最新推荐文章于 2024-07-12 16:34:36 发布

阅读量114

点赞数 1

分类专栏： linux 文章标签： linux 运维服务器

本文链接：https://blog.csdn.net/hhwyqwqhhwy/article/details/138968558

版权

linux 专栏收录该内容

4 篇文章 0 订阅

订阅专栏

#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#include <signal.h>
#include <sys/time.h>
#include "time.h"

#include <stdio.h>
#include <time.h>

node_att atttep;
static int os_timer_create(timer_t *timerid, void (*callback)(union sigval v), void *arg)
{
    struct sigevent evp;
    memset(&evp, 0, sizeof(evp));

    evp.sigev_value.sival_ptr = arg;
    evp.sigev_notify = SIGEV_THREAD;
    evp.sigev_notify_function = callback;

    return timer_create(CLOCK_MONOTONIC, &evp, timerid);
}

// 毫秒
static int os_timer_start(timer_t *timerid, int first, int period)
{
    struct itimerspec it;
    memset(&it, 0, sizeof(it));

    it.it_value.tv_sec = first / 1000;
    it.it_value.tv_nsec = first % 1000 * 1000 * 1000; // 第一次触发时间:x秒后
    it.it_interval.tv_sec = period / 1000;            // 定时器间隔:x秒
    it.it_interval.tv_nsec = period % 1000 * 1000 * 1000;

     DBG_PRINTF(LOG_INFO,"it.it_value.tv_nsec %ld %ld\n", it.it_value.tv_sec ,it.it_value.tv_nsec);
     DBG_PRINTF(LOG_INFO,"it.it_value.it_interval %ld %ld\n", it.it_interval.tv_sec ,it.it_interval.tv_nsec);

    return timer_settime(*timerid, 0, &it, NULL);
}

static int os_timer_cancel(timer_t *timerid)
{
    struct itimerspec it;
    memset(&it, 0, sizeof(it));

    return timer_settime(*timerid, 0, &it, NULL);
}

static int os_timer_delete(timer_t *timerid)
{
    return timer_delete(*timerid);
}

static void set_timer(timer_t *timerid, int first, int period, void *timer_cb, void *arg)
{
    os_timer_create(timerid, timer_cb, arg);
    os_timer_start(timerid, first, period);
}

void timer_create_0(timer_tt *pt)
{
    set_timer(&pt->timerid, pt->first, pt->period, pt->callback, pt->arg);
}
void timer_cancel(timer_tt *pt)
{
    os_timer_cancel(&pt->timerid);
}
void timer_del(timer_tt *pt)
{
    os_timer_delete(&pt->timerid);
}

/

void timer_callback(union sigval v)
{
    timer_tt *tt = (timer_tt *)v.sival_ptr;
    DBG_PRINTF(LOG_INFO, "###fff %ld\n", (long)tt->timerid);
    DBG_PRINTF(LOG_INFO, "###fff %ld\n", (long)tt->times);
    if (tt->times)
    {
        tt->times--;
    }
    if (tt->times == 0)
    {
        os_timer_cancel(&tt->timerid);
        DBG_PRINTF(LOG_INFO, "os_timer_cancel\n");
    }
    if (get_mysolt(*tt, atttep) == 0)
    {
        DBG_PRINTF(LOG_INFO, "myslot time is \n");
    }
}

void timer_tt_match_node_att(timer_tt *p_tt, node_att *p_atttep)
{
    time_t now;
    time(&now);
    p_tt->first = (p_atttep->time * 1000) - ((now % p_atttep->time) * 1000);
    p_tt->period = (p_atttep->time * 1000);
}

int get_mysolt(timer_tt tt, node_att atttep)
{
    time_t now;
    time(&now);
    int temp = now / atttep.time;

    if ((temp % atttep.number) == atttep.index)
    {
        DBG_PRINTF(LOG_INFO, "mysolt\r\n");
        return 0;
    }
    else
    {
        return -1;
    }
}

int main(int argc, char *argv[])
{
    timer_tt tt;
    /
    tt.timerid;
    tt.first = 5000;
    tt.period = 1000;
    tt.times = (int)TimerRunForever;
    DBG_PRINTF(LOG_INFO, "tt.times %d\n", tt.times);
    tt.callback = &timer_callback;
    tt.arg = &tt.timerid;

    ///
    atttep.number = 5;
    atttep.index = 1;
    atttep.time = 3;
    //

    DBG_PRINTF(LOG_INFO, "-------------------------\n");
#if 0
        timer_t timer_id;
        set_timer(&timer_id, 5000,1000, timer_callback, &timer_id);
        DBG_PRINTF(LOG_INFO,"*** %ld\n", (long)timer_id);
#else
    // timer_create_0(&tt);
    // DBG_PRINTF(LOG_INFO,"*** %ld\n", (long)tt.timerid);
#endif
    timer_tt_match_node_att(&tt, &atttep);
    timer_create_0(&tt);
    while (1)
    {
        // nod_send_api(atttep);
    }
    return 0;
}

#ifndef MODEM_H
#define MODEM_H

#ifdef __cplusplus
extern "C" {
#endif

#include <pthread.h>
#include <locale.h>
#include <stdio.h>
#include <time.h>
typedef struct timer_tt {
  timer_t timerid;
  int first;
  int period;
  int times;
  void *arg;
  void (*callback)(union sigval v);

} timer_tt;


typedef enum TimerRunTimes
{
        TimerRunZero    = 0x00000000,
        TimerRunOne    = 0x00000001,
        TimerRunForever=  0x7FFFFFFF
} TimerRunTimes;



void timer_create_0(timer_tt *pt);

void timer_cancel(timer_tt *pt);

void timer_del(timer_tt *pt);

///
typedef enum
{
	LOG_DEBUG = 0,
	LOG_INFO,
	LOG_WARN,
	LOG_ERROR,
}E_LOGLEVEL;

#define DEBUG 1
#if DEBUG

static char *EM_LOGLevelGet(const int level)
{
	switch(level)
	{
		case LOG_DEBUG:
			return "DEBUG";
		case LOG_INFO:
			return "INFO";
		case LOG_WARN:
			return "WARN";
		case LOG_ERROR:
			return "ERROR";
	}
	return "UNKNOW";
}
         
#define DBG_PRINTF(level,fmt, ...)                                                                         \
        do                                                                                           \
        {                                                                                            \
                time_t now = time(NULL);                                                             \
                struct tm *local = localtime(&now);                                                  \
                setlocale(LC_TIME, "");                                                                 \
                fprintf(stderr, "[%s][%d-%d-%d %d:%d:%d][%s,%s,%d]:" fmt,EM_LOGLevelGet(level),local->tm_year + 1900, local->tm_mon + 1, local->tm_mday,local->tm_hour, local->tm_min, local->tm_sec,__FILE__, __FUNCTION__, __LINE__, ##__VA_ARGS__); \
                fprintf(stderr, "\n");                                                               \
        } while (0)

#else
#define DBG_PRINTF(fmt, ...)
#endif


/


typedef struct node_att {
        int number;
        int time;
        int index;
} node_att;



#ifdef __cplusplus
}
#endif
#endif