1

/*

     2

This file is part of CanFestival, a library implementing CanOpen Stack.

     3

     4

Copyright (C): Edouard TISSERANT and Francis DUPIN

     5

Copyright (C) Win32 Port Leonid Tochinski

     6

     7

See COPYING file for copyrights details.

     8

     9

This library is free software; you can redistribute it and/or

    10

modify it under the terms of the GNU Lesser General Public

    11

License as published by the Free Software Foundation; either

    12

version 2.1 of the License, or (at your option) any later version.

    13

    14

This library is distributed in the hope that it will be useful,

    15

but WITHOUT ANY WARRANTY; without even the implied warranty of

    16

MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

    17

Lesser General Public License for more details.

    18

    19

You should have received a copy of the GNU Lesser General Public

    20

License along with this library; if not, write to the Free Software

    21

Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

    22

*/

    23

    24

#include <windows.h>

    25

#include <stdlib.h>

    26

#include <sys/timeb.h>

    27

    28

#ifdef __cplusplus

    29

extern "C" {

    30

#endif

    31

    32

#include "applicfg.h"

    33

#include "can_driver.h"

    34

#include "timer.h"

    35

#include "timers_driver.h"

    36

    37

#ifdef __cplusplus

    38

};

    39

#endif

    40

    41

struct _timeb timebuffer;

    42

    43

/* Synchronization Object Implementation */

    44

CRITICAL_SECTION CanFestival_mutex;

    45

HANDLE timer_thread = NULL;

    46

HANDLE timer = NULL;

    47

    48

int stop_timer=0;

    49

    50

static TimerCallback_t init_callback;

    51

    52

    53

void EnterMutex(void)

    54

{

    55

	EnterCriticalSection(&CanFestival_mutex);

    56

}

    57

    58

void LeaveMutex(void)

    59

{

    60

	LeaveCriticalSection(&CanFestival_mutex);

    61

}

    62

    63

// --------------- CAN Receive Thread Implementation ---------------

    64

    65

void CreateReceiveTask(CAN_HANDLE fd0, TASK_HANDLE* Thread, void* ReceiveLoopPtr)

    66

{

    67

	unsigned long thread_id = 0;

    68

	*Thread = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)ReceiveLoopPtr, fd0, 0, &thread_id);

    69

}

    70

    71

void WaitReceiveTaskEnd(TASK_HANDLE *Thread)

    72

{

    73

	if(WaitForSingleObject(*Thread, 1000) == WAIT_TIMEOUT)

    74

	{

    75

		TerminateThread(*Thread, -1);

    76

	}

    77

	CloseHandle(*Thread);

    78

}

    79

    80

int TimerThreadLoop(void)

    81

{

    82

    83

    84

	while(!stop_timer)

    85

	{

    86

		WaitForSingleObject(timer, INFINITE);

    87

		if(stop_timer)

    88

			break;

    89

		_ftime(&timebuffer);

    90

		EnterMutex();

    91

		TimeDispatch();

    92

		LeaveMutex();

    93

	}

    94

	return 0;

    95

}

    96

    97

void TimerInit(void)

    98

{

    99

	LARGE_INTEGER liDueTime;

   100

	liDueTime.QuadPart = 0;

   101

   102

	InitializeCriticalSection(&CanFestival_mutex);

   103

   104

	timer = CreateWaitableTimer(NULL, FALSE, NULL);

   105

	if(NULL == timer)

   106

    {

   107

        printf("CreateWaitableTimer failed (%d)\n", GetLastError());

   108

    }

   109

   110

	// Take first absolute time ref in milliseconds.

   111

	_ftime(&timebuffer);

   112

}

   113

   114

void TimerCleanup(void)

   115

{

   116

	DeleteCriticalSection(&CanFestival_mutex);

   117

}

   118

   119

void StopTimerLoop(TimerCallback_t exitfunction)

   120

{

   121

	EnterMutex();

   122

	exitfunction(NULL,0);

   123

	LeaveMutex();

   124

   125

	stop_timer = 1;

   126

	setTimer(0);

   127

	if(WaitForSingleObject(timer_thread,1000) == WAIT_TIMEOUT)

   128

	{

   129

		TerminateThread(timer_thread, -1);

   130

	}

   131

	CloseHandle(timer);

   132

	CloseHandle(timer_thread);

   133

}

   134

   135

void StartTimerLoop(TimerCallback_t _init_callback)

   136

{

   137

	unsigned long timer_thread_id;

   138

	stop_timer = 0;

   139

	init_callback = _init_callback;

   140

	EnterMutex();

   141

		// At first, TimeDispatch will call init_callback.

   142

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

   143

	LeaveMutex();

   144

	timer_thread = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)TimerThreadLoop, NULL, 0, &timer_thread_id);

   145

}

   146

   147

/* Set the next alarm */

   148

void setTimer(TIMEVAL value)

   149

{

   150

	if(value == TIMEVAL_MAX)

   151

		CancelWaitableTimer(timer);

   152

	else

   153

	{

   154

		LARGE_INTEGER liDueTime;

   155

   156

		/* arg 2 of SetWaitableTimer take 100 ns interval */

   157

		liDueTime.QuadPart = (-1 * value);

   158

		//printf("SetTimer(%llu)\n", value);

   159

   160

		if (!SetWaitableTimer(timer, &liDueTime, 0, NULL, NULL, FALSE))

   161

		{

   162

			printf("SetWaitableTimer failed (%d)\n", GetLastError());

   163

		}

   164

	}

   165

}

   166

   167

/* Get the elapsed time since the last occured alarm */

   168

TIMEVAL getElapsedTime(void)

   169

{

   170

	struct _timeb timetmp;

   171

	_ftime(&timetmp);

   172

	return (timetmp.time - timebuffer.time) * 10000000 + (timetmp.millitm - timebuffer.millitm) * 10000;

   173

}

   174