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

#include "applicfg.h"

    29

#include "can_driver.h"

    30

#include "timer.h"

    31

#include "timers_driver.h"

    32

    33

    34

struct _timeb timebuffer;

    35

    36

/* Synchronization Object Implementation */

    37

CRITICAL_SECTION CanFestival_mutex;

    38

HANDLE timer_thread = NULL;

    39

HANDLE timer = NULL;

    40

    41

stop_timer=0;

    42

    43

static TimerCallback_t init_callback;

    44

    45

    46

void EnterMutex(void)

    47

{

    48

	EnterCriticalSection(&CanFestival_mutex);

    49

}

    50

    51

void LeaveMutex(void)

    52

{

    53

	LeaveCriticalSection(&CanFestival_mutex);

    54

}

    55

    56

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

    57

    58

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

    59

{

    60

	unsigned long thread_id = 0;

    61

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

    62

}

    63

    64

void WaitReceiveTaskEnd(TASK_HANDLE *Thread)

    65

{

    66

	WaitForSingleObject(*Thread, INFINITE);

    67

	CloseHandle(*Thread);

    68

}

    69

    70

int TimerThreadLoop(void)

    71

{

    72

	int ret = 0;

    73

	EnterMutex();

    74

	// At first, TimeDispatch will call init_callback.

    75

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

    76

	LeaveMutex();

    77

    78

	while(!stop_timer && ret == WAIT_OBJECT_0)

    79

	{

    80

		ret = WaitForSingleObject(timer, INFINITE);

    81

		_ftime(&timebuffer);

    82

		EnterMutex();

    83

		TimeDispatch();

    84

		LeaveMutex();

    85

	}

    86

	return 0;

    87

}

    88

    89

void TimerInit(void)

    90

{

    91

	LARGE_INTEGER liDueTime;

    92

	liDueTime.QuadPart = 0;

    93

    94

	InitializeCriticalSection(&CanFestival_mutex);

    95

    96

	timer = CreateWaitableTimer(NULL, TRUE, NULL);

    97

	if(NULL == timer)

    98

    {

    99

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

   100

    }

   101

   102

	// Take first absolute time ref in milliseconds.

   103

	_ftime(&timebuffer);

   104

}

   105

   106

void TimerCleanup(void)

   107

{

   108

	DeleteCriticalSection(&CanFestival_mutex);

   109

}

   110

   111

void StopTimerLoop(TimerCallback_t exitfunction)

   112

{

   113

	EnterMutex();

   114

	exitfunction(NULL,0);

   115

	LeaveMutex();

   116

   117

	stop_timer = 1;

   118

	CloseHandle(timer);

   119

	WaitForSingleObject(timer_thread, INFINITE);

   120

	CloseHandle(timer_thread);

   121

}

   122

   123

void StartTimerLoop(TimerCallback_t _init_callback)

   124

{

   125

	unsigned long timer_thread_id;

   126

	stop_timer = 0;

   127

	init_callback = _init_callback;

   128

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

   129

}

   130

   131

/* Set the next alarm */

   132

void setTimer(TIMEVAL value)

   133

{

   134

	if(value == TIMEVAL_MAX)

   135

	{

   136

		/* cancel timer */

   137

		CancelWaitableTimer(timer);

   138

	}

   139

	else

   140

	{

   141

		LARGE_INTEGER liDueTime;

   142

   143

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

   144

		liDueTime.QuadPart = -value;

   145

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

   146

   147

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

   148

		{

   149

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

   150

		}

   151

	}

   152

}

   153

   154

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

   155

TIMEVAL getElapsedTime(void)

   156

{

   157

	struct _timeb timetmp;

   158

	_ftime(&timetmp);

   159

	return (timetmp.time - timebuffer.time) * 1000000 + (timetmp.millitm - timebuffer.millitm) * 1000;

   160

}

   161