1

#include <stdlib.h>

     2

     3

#include <sys/time.h>

     4

#include <pthread.h> 

     5

#include <signal.h>

     6

     7

#include "applicfg.h"

     8

#include "timer.h"

     9

    10

pthread_mutex_t CanFestival_mutex = PTHREAD_MUTEX_INITIALIZER;

    11

    12

TASK_HANDLE TimerLoopThread;

    13

    14

TIMEVAL last_time_set = TIMEVAL_MAX;

    15

    16

struct timeval last_sig;

    17

    18

timer_t timer;

    19

    20

void TimerCleanup(void)

    21

{

    22

	/* only used in realtime apps */

    23

}

    24

    25

void EnterMutex(void)

    26

{

    27

	pthread_mutex_lock(&CanFestival_mutex); 

    28

}

    29

    30

void LeaveMutex(void)

    31

{

    32

	pthread_mutex_unlock(&CanFestival_mutex);

    33

}

    34

    35

void timer_notify(sigval_t val)

    36

{

    37

	gettimeofday(&last_sig,NULL);

    38

	EnterMutex();

    39

	TimeDispatch();

    40

	LeaveMutex();

    41

//	printf("getCurrentTime() return=%u\n", p.tv_usec);

    42

}

    43

    44

void TimerInit(void)

    45

{

    46

	struct sigevent sigev;

    47

    48

	// Take first absolute time ref.

    49

	gettimeofday(&last_sig,NULL);

    50

    56

	memset (&sigev, 0, sizeof (struct sigevent));

    57

	sigev.sigev_value.sival_int = 0;

    58

	sigev.sigev_notify = SIGEV_THREAD;

    59

	sigev.sigev_notify_attributes = NULL;

    60

	sigev.sigev_notify_function = timer_notify;

    61

    62

	timer_create (CLOCK_REALTIME, &sigev, &timer);

    64

}

    65

    66

void StopTimerLoop(TimerCallback_t exitfunction)

    67

{

    68

	EnterMutex();

    69

	timer_delete (timer);

    70

	exitfunction(NULL,0);

    71

	LeaveMutex();

    72

}

    73

    74

void StartTimerLoop(TimerCallback_t init_callback)

    75

{

    76

	EnterMutex();

    77

	// At first, TimeDispatch will call init_callback.

    78

	SetAlarm(NULL, 0, init_callback, 0, 0);

    79

	LeaveMutex();

    80

}

    81

    82

void canReceiveLoop_signal(int sig)

    83

{

    84

}

    85

/* We assume that ReceiveLoop_task_proc is always the same */

    86

static void (*unixtimer_ReceiveLoop_task_proc)(CAN_PORT) = NULL;

    87

    88

/**

    89

 * Enter in realtime and start the CAN receiver loop

    90

 * @param port

    91

 */

    92

void* unixtimer_canReceiveLoop(void* port)

    93

{

    94

    95

    /*get signal*/

    96

    signal(SIGTERM, canReceiveLoop_signal);

    97

    unixtimer_ReceiveLoop_task_proc((CAN_PORT)port);

    98

}

    99

   100

void CreateReceiveTask(CAN_PORT port, TASK_HANDLE* Thread, void* ReceiveLoopPtr)

   101

{

   102

    unixtimer_ReceiveLoop_task_proc = ReceiveLoopPtr;

   103

	pthread_create(Thread, NULL, unixtimer_canReceiveLoop, (void*)port);

   104

}

   105

   106

void WaitReceiveTaskEnd(TASK_HANDLE *Thread)

   107

{

   108

	pthread_kill(*Thread, SIGTERM);

   109

	pthread_join(*Thread, NULL);

   110

}

   111

   112

#define maxval(a,b) ((a>b)?a:b)

   113

void setTimer(TIMEVAL value)

   114

{

   115

//	printf("setTimer(TIMEVAL value=%d)\n", value);

   116

	// TIMEVAL is us whereas setitimer wants ns...

   117

	long tv_nsec = 1000 * (maxval(value,1)%1000000);

   118

	time_t tv_sec = value/1000000;

   119

	struct itimerspec timerValues;

   120

	timerValues.it_value.tv_sec = tv_sec;

   121

	timerValues.it_value.tv_nsec = tv_nsec;

   122

	timerValues.it_interval.tv_sec = 0;

   123

	timerValues.it_interval.tv_nsec = 0;

   124

   125

 	timer_settime (timer, 0, &timerValues, NULL);

   126

}

   127

   128

TIMEVAL getElapsedTime(void)

   129

{

   130

	struct timeval p;

   131

	gettimeofday(&p,NULL);

   132

//	printf("getCurrentTime() return=%u\n", p.tv_usec);

   133

	return (p.tv_sec - last_sig.tv_sec)* 1000000 + p.tv_usec - last_sig.tv_usec;

   134

}