CanFestival: drivers/win32/timers

00001 /*
+00002 This file is part of CanFestival, a library implementing CanOpen Stack.
+00003 
+00004 Copyright (C): Edouard TISSERANT and Francis DUPIN
+00005 Copyright (C) Win32 Port Leonid Tochinski
+00006 
+00007 See COPYING file for copyrights details.
+00008 
+00009 This library is free software; you can redistribute it and/or
+00010 modify it under the terms of the GNU Lesser General Public
+00011 License as published by the Free Software Foundation; either
+00012 version 2.1 of the License, or (at your option) any later version.
+00013 
+00014 This library is distributed in the hope that it will be useful,
+00015 but WITHOUT ANY WARRANTY; without even the implied warranty of
+00016 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+00017 Lesser General Public License for more details.
+00018 
+00019 You should have received a copy of the GNU Lesser General Public
+00020 License along with this library; if not, write to the Free Software
+00021 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+00022 */
+00023 
+00024 
+00025 
+00026 #include <windows.h>
+00027 #include <stdlib.h>
+00028 
+00029 extern "C"
+00030 {
+00031 #include "applicfg.h"
+00032 #include "can_driver.h"
+00033 #include "timer.h"
+00034 #include "timers_driver.h"
+00035 };
+00036 
+00037 // --------------- Synchronization Object Implementation ---------------
+00038 class ccritical_section
+00039    {
+00040    public:
+00041       ccritical_section()
+00042          {
+00043          ::InitializeCriticalSection(&m_cs);
+00044          }
+00045       ~ccritical_section()
+00046          {
+00047          ::DeleteCriticalSection(&m_cs);
+00048          }
+00049       void enter()
+00050          {
+00051          ::EnterCriticalSection(&m_cs);
+00052          }
+00053       void leave()
+00054          {
+00055          ::LeaveCriticalSection(&m_cs);
+00056          }
+00057    private:
+00058       CRITICAL_SECTION m_cs;
+00059    };
+00060 
+00061 static ccritical_section g_cs;
+00062 
+00063 
+00064 void EnterMutex(void)
+00065    {
+00066    g_cs.enter();
+00067    }
+00068 
+00069 void LeaveMutex(void)
+00070    {
+00071    g_cs.leave();
+00072    }
+00073 // --------------- Synchronization Object Implementation ---------------
+00074 
+00075 
+00076 // --------------- CAN Receive Thread Implementation ---------------
+00077 
+00078 void CreateReceiveTask(CAN_HANDLE fd0, TASK_HANDLE* Thread, void* ReceiveLoopPtr)
+00079    {
+00080    unsigned long thread_id = 0;
+00081    *Thread = ::CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)ReceiveLoopPtr, fd0, 0, &thread_id);
+00082    }
+00083 
+00084 void WaitReceiveTaskEnd(TASK_HANDLE Thread)
+00085    {
+00086    ::WaitForSingleObject(Thread, INFINITE);
+00087    ::CloseHandle(Thread);
+00088    //*Thread = NULL;
+00089    }
+00090 // --------------- CAN Receive Thread Implementation ---------------
+00091 
+00092 
+00093 // --------------- Timer Thread Implementation ---------------
+00094 class class_timers
+00095    {
+00096    public:
+00097       class_timers();
+00098       ~class_timers();
+00099       void start_timer_thread();
+00100       void resume_timer_thread();
+00101       void stop_timer_thread();
+00102       void set_timer(TIMEVAL value);
+00103       TIMEVAL get_elapsed_time();
+00104    private:
+00105       TIMEVAL get_timer() const;   
+00106       static DWORD WINAPI timer_loop_thread_proc(void* arg);
+00107    private:
+00108       TIMEVAL m_last_occured_alarm_time;
+00109       volatile TIMEVAL m_last_alarm_set_time;
+00110       HANDLE m_timer_thread;
+00111       volatile bool m_continue_timer_loop;
+00112       bool m_use_hi_res_timer;
+00113       double m_counts_per_usec;
+00114    };
+00115 
+00116 class_timers::class_timers() : m_last_occured_alarm_time(TIMEVAL_MAX),
+00117       m_last_alarm_set_time(TIMEVAL_MAX),
+00118       m_timer_thread(0),
+00119       m_continue_timer_loop(false),
+00120       m_use_hi_res_timer(false),
+00121       m_counts_per_usec(0.)
+00122    {
+00123    // initialize hi resolution timer
+00124    LARGE_INTEGER counts_per_sec = {0, 0};
+00125    if (::QueryPerformanceFrequency(&counts_per_sec) && counts_per_sec.QuadPart > 0)
+00126       {
+00127       m_use_hi_res_timer = true;
+00128       m_counts_per_usec = counts_per_sec.QuadPart / 1000000.;
+00129       }
+00130    m_use_hi_res_timer = true;
+00131    }
+00132 
+00133 class_timers::~class_timers()
+00134    {
+00135    stop_timer_thread();
+00136    }
+00137 
+00138 // time is in micro seconds
+00139 TIMEVAL class_timers::get_timer() const
+00140    {
+00141    if (m_use_hi_res_timer)
+00142       {
+00143       LARGE_INTEGER performance_count = {0, 0};
+00144       ::QueryPerformanceCounter(&performance_count);
+00145       return (TIMEVAL)(performance_count.QuadPart / m_counts_per_usec);
+00146       }
+00147    // hi-res timer is unavailable
+00148    return 1000 * ::GetTickCount();
+00149    }
+00150 
+00151 DWORD WINAPI class_timers::timer_loop_thread_proc(void* arg)
+00152    {
+00153    class_timers* This = reinterpret_cast<class_timers*>(arg);
+00154    while (This->m_continue_timer_loop)
+00155       {
+00156       TIMEVAL cur_time = This->get_timer();
+00157       if (cur_time >= This->m_last_alarm_set_time)
+00158          {
+00159          This->m_last_occured_alarm_time = cur_time;
+00160          This->m_last_alarm_set_time = TIMEVAL_MAX;         
+00161          EnterMutex();
+00162          TimeDispatch();
+00163          LeaveMutex();
+00164          }
+00165       else
+00166          {
+00167          ::Sleep(1);
+00168          }
+00169       }
+00170    return 0;
+00171    }
+00172 
+00173 void class_timers::start_timer_thread()
+00174    {
+00175    if (m_timer_thread == 0)
+00176       {
+00177       unsigned long thread_id = 0;
+00178       m_timer_thread = ::CreateThread(NULL, 0, &timer_loop_thread_proc, this, CREATE_SUSPENDED, &thread_id);
+00179       m_last_alarm_set_time = TIMEVAL_MAX;
+00180       m_last_occured_alarm_time = get_timer();
+00181       }
+00182    }
+00183 
+00184 void class_timers::resume_timer_thread()
+00185    {
+00186    if (m_timer_thread)
+00187       {
+00188       m_continue_timer_loop = true;
+00189       ::ResumeThread(m_timer_thread);
+00190       }
+00191    }
+00192 
+00193 void class_timers::stop_timer_thread()
+00194    {
+00195    if (m_timer_thread)
+00196       {
+00197       m_continue_timer_loop = false;
+00198       ::WaitForSingleObject(m_timer_thread, INFINITE);
+00199       ::CloseHandle(m_timer_thread);
+00200       m_timer_thread = 0;
+00201       }
+00202    }
+00203 
+00204 void class_timers::set_timer(TIMEVAL value)
+00205    {
+00206    m_last_alarm_set_time = (value == TIMEVAL_MAX) ? TIMEVAL_MAX : get_timer() + value;
+00207    }
+00208 
+00209 // elapsed time since last occured alarm
+00210 TIMEVAL class_timers::get_elapsed_time()
+00211    {
+00212    return get_timer() - m_last_occured_alarm_time;
+00213    }
+00214 
+00215 // ----------------------------------------------------------
+00216 
+00217 static class_timers s_timers;
+00218 
+00219 void StartTimerLoop(TimerCallback_t init_callback)
+00220    {
+00221    s_timers.start_timer_thread();
+00222    // At first, TimeDispatch will call init_callback.
+00223    if (init_callback != NULL)
+00224       SetAlarm(NULL, 0, init_callback, (TIMEVAL)0, (TIMEVAL)0);
+00225    s_timers.resume_timer_thread();
+00226    }
+00227 
+00228 void StopTimerLoop(void)
+00229    {
+00230    s_timers.stop_timer_thread();
+00231    }
+00232 
+00233 void setTimer(TIMEVAL value)
+00234    {
+00235    s_timers.set_timer(value);
+00236    }
+00237 
+00238 TIMEVAL getElapsedTime(void)
+00239    {
+00240    return s_timers.get_elapsed_time();
+00241    }
+
timers_win32.cpp
