1

#include <stdlib.h>

     2

     3

#include <sys/time.h>

     4

#include <pthread.h>

     5

#include <signal.h>

     6

#include <time.h>

     7

     8

#include <applicfg.h>

     9

#include <timers.h>

    10

    11

static pthread_mutex_t CanFestival_mutex = PTHREAD_MUTEX_INITIALIZER;

    12

    13

static struct timeval last_sig;

    14

    15

static timer_t timer;

    16

    17

void TimerCleanup(void)

    18

{

    19

	/* only used in realtime apps */

    20

}

    21

    22

void EnterMutex(void)

    23

{

    24

	if(pthread_mutex_lock(&CanFestival_mutex)) {

    25

		fprintf(stderr, "pthread_mutex_lock() failed\n");

    26

	}

    27

}

    28

    29

void LeaveMutex(void)

    30

{

    31

	if(pthread_mutex_unlock(&CanFestival_mutex)) {

    32

		fprintf(stderr, "pthread_mutex_unlock() failed\n");

    33

	}

    34

}

    35

    36

void timer_notify(sigval_t val)

    37

{

    38

	if(gettimeofday(&last_sig,NULL)) {

    39

		perror("gettimeofday()");

    40

	}

    41

	EnterMutex();

    42

	TimeDispatch();

    43

	LeaveMutex();

    44

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

    45

}

    46

    47

void TimerInit(void)

    48

{

    49

	struct sigevent sigev;

    50

    51

	// Take first absolute time ref.

    52

	if(gettimeofday(&last_sig,NULL)){

    53

		perror("gettimeofday()");

    54

	}

    55

    56

#if defined(__UCLIBC__)

    57

	int ret;

    58

	ret = timer_create(CLOCK_PROCESS_CPUTIME_ID, NULL, &timer);

    59

	signal(SIGALRM, timer_notify);

    60

#else

    61

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

    62

	sigev.sigev_value.sival_int = 0;

    63

	sigev.sigev_notify = SIGEV_THREAD;

    64

	sigev.sigev_notify_attributes = NULL;

    65

	sigev.sigev_notify_function = timer_notify;

    66

    67

	if(timer_create (CLOCK_REALTIME, &sigev, &timer)) {

    68

		perror("timer_create()");

    69

	}

    70

#endif

    71

}

    72

    73

void StopTimerLoop(TimerCallback_t exitfunction)

    74

{

    75

	EnterMutex();

    76

	if(timer_delete (timer)) {

    77

		perror("timer_delete()");

    78

	}

    79

	exitfunction(NULL,0);

    80

	LeaveMutex();

    81

}

    82

    83

void StartTimerLoop(TimerCallback_t init_callback)

    84

{

    85

	EnterMutex();

    86

	// At first, TimeDispatch will call init_callback.

    87

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

    88

	LeaveMutex();

    89

}

    90

    91

void canReceiveLoop_signal(int sig)

    92

{

    93

}

    94

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

    95

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

    96

    97

/**

    98

 * Enter in realtime and start the CAN receiver loop

    99

 * @param port

   100

 */

   101

void* unixtimer_canReceiveLoop(void* port)

   102

{

   103

    /*get signal*/

   104

  	//  if(signal(SIGTERM, canReceiveLoop_signal) == SIG_ERR) {

   105

	//		perror("signal()");

   106

	//}

   107

   108

    // Set the cancelation state for immediatly cancel the task

   109

    int ret;

   110

   111

    ret = pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, NULL);

   112

   113

    if (ret != 0)

   114

        perror("Can't enable the cancelation of the receiving task");

   115

   116

    ret = pthread_setcanceltype(PTHREAD_CANCEL_ASYNCHRONOUS, NULL);

   117

   118

    if (ret != 0)

   119

        perror("Can't set the asynchronous cancel typ");

   120

   121

    unixtimer_ReceiveLoop_task_proc((CAN_PORT)port);

   122

   123

    return NULL;

   124

}

   125

   126

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

   127

{

   128

    unixtimer_ReceiveLoop_task_proc = ReceiveLoopPtr;

   129

	if(pthread_create(Thread, NULL, unixtimer_canReceiveLoop, (void*)port)) {

   130

		perror("pthread_create()");

   131

	}

   132

}

   133

   134

void WaitReceiveTaskEnd(TASK_HANDLE *Thread)

   135

{

   136

	if(pthread_cancel(*Thread)) {

   137

		perror("pthread_cancel()");

   138

	}

   139

	if(pthread_join(*Thread, NULL)) {

   140

		perror("pthread_join()");

   141

	}

   142

}

   143

   144

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

   145

void setTimer(TIMEVAL value)

   146

{

   147

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

   148

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

   149

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

   150

	time_t tv_sec = value/1000000;

   151

	struct itimerspec timerValues;

   152

	timerValues.it_value.tv_sec = tv_sec;

   153

	timerValues.it_value.tv_nsec = tv_nsec;

   154

	timerValues.it_interval.tv_sec = 0;

   155

	timerValues.it_interval.tv_nsec = 0;

   156

   157

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

   158

}

   159

   160

TIMEVAL getElapsedTime(void)

   161

{

   162

	struct timeval p;

   163

	if(gettimeofday(&p,NULL)) {

   164

		perror("gettimeofday()");

   165

	}

   166

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

   167

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

   168

}