CanFestival: drivers/win32/drivers

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  CAN driver interface.
+00026 */
+00027 
+00028 #include <windows.h>
+00029 
+00030 extern "C"
+00031    {
+00032 #define DLL_CALL(funcname) (*_##funcname)
+00033 #define FCT_PTR_INIT =NULL
+00034 #include "canfestival.h"
+00035 #include "timer.h"
+00036 
+00037 #include "timers_driver.h"
+00038    };
+00039 
+00040 typedef UNS8 (*CANRECEIVE_DRIVER_PROC)(void* inst, Message *m);
+00041 typedef UNS8 (*CANSEND_DRIVER_PROC)(void* inst, const Message *m);
+00042 typedef void* (*CANOPEN_DRIVER_PROC)(s_BOARD *board);
+00043 typedef int (*CANCLOSE_DRIVER_PROC)(void* inst);
+00044 
+00045 
+00046 class driver_procs
+00047    {
+00048    public:
+00049       driver_procs();
+00050       ~driver_procs();
+00051 
+00052       HMODULE load_canfestival_driver(LPCTSTR driver_name);
+00053       bool can_driver_valid() const;
+00054 
+00055    public:
+00056       // can driver
+00057       CANRECEIVE_DRIVER_PROC m_canReceive;
+00058       CANSEND_DRIVER_PROC m_canSend;
+00059       CANOPEN_DRIVER_PROC m_canOpen;
+00060       CANCLOSE_DRIVER_PROC m_canClose;
+00061 
+00062       // driver module habndle
+00063       HMODULE m_driver_handle;
+00064    };
+00065 
+00066 driver_procs::driver_procs() : m_canReceive(0),
+00067       m_canSend(0),
+00068       m_canOpen(0),
+00069       m_canClose(0),
+00070       m_driver_handle(0)
+00071    {}
+00072 
+00073 driver_procs::~driver_procs()
+00074    {
+00075    if (m_driver_handle)
+00076       ::FreeLibrary(m_driver_handle);
+00077    }
+00078 
+00079 bool driver_procs::can_driver_valid() const
+00080    {
+00081    return ((m_canReceive != NULL) &&
+00082            (m_canSend != NULL) &&
+00083            (m_canOpen != NULL) &&
+00084            (m_canClose != NULL));
+00085    }
+00086 
+00087 // GetProcAddress doesn't have an UNICODE version for NT
+00088 #ifdef UNDER_CE
+00089   #define myTEXT(str) TEXT(str)
+00090 #else
+00091   #define myTEXT(str) str
+00092 #endif
+00093 
+00094 HMODULE driver_procs::load_canfestival_driver(LPCTSTR driver_name)
+00095    {
+00096    if (can_driver_valid())
+00097       return m_driver_handle;
+00098    m_driver_handle = ::LoadLibrary(driver_name);
+00099    if (m_driver_handle == NULL)
+00100       return NULL;
+00101 
+00102    m_canReceive = (CANRECEIVE_DRIVER_PROC)::GetProcAddress(m_driver_handle, myTEXT("canReceive_driver"));
+00103    m_canSend = (CANSEND_DRIVER_PROC)::GetProcAddress(m_driver_handle, myTEXT("canSend_driver"));
+00104    m_canOpen = (CANOPEN_DRIVER_PROC)::GetProcAddress(m_driver_handle, myTEXT("canOpen_driver"));
+00105    m_canClose = (CANCLOSE_DRIVER_PROC)::GetProcAddress(m_driver_handle, myTEXT("canClose_driver"));
+00106    return can_driver_valid()?m_driver_handle:NULL;
+00107    }
+00108 
+00109 struct driver_data
+00110    {
+00111    CO_Data * d;
+00112    HANDLE receive_thread;
+00113    void* inst;
+00114    volatile bool continue_receive_thread;
+00115    };
+00116 
+00117 driver_procs s_driver_procs;
+00118 
+00119 LIB_HANDLE LoadCanDriver(char* driver_name)
+00120    {
+00121                 return s_driver_procs.load_canfestival_driver((LPCTSTR)driver_name);
+00122    }
+00123 
+00124 UNS8 canReceive(CAN_PORT fd0, Message *m)
+00125    {
+00126    if (fd0 != NULL && s_driver_procs.m_canReceive != NULL)
+00127            {
+00128                   driver_data* data = (driver_data*)fd0;
+00129                   return (*s_driver_procs.m_canReceive)(data->inst, m);
+00130            }
+00131    return 1;
+00132    }
+00133 
+00134 void* canReceiveLoop(CAN_PORT fd0)
+00135    {
+00136    driver_data* data = (driver_data*)fd0;
+00137    Message m;
+00138    while (data->continue_receive_thread)
+00139       {
+00140       if (!canReceive(fd0, &m))
+00141          {
+00142          EnterMutex();
+00143          canDispatch(data->d, &m);
+00144          LeaveMutex();
+00145          }
+00146       else
+00147          {
+00148                  break;
+00149          ::Sleep(1);
+00150          }
+00151       }
+00152    return 0;
+00153    }
+00154 
+00155 /***************************************************************************/
+00156 UNS8 canSend(CAN_PORT fd0, Message *m)
+00157    {
+00158    if (fd0 != NULL && s_driver_procs.m_canSend != NULL)
+00159       {
+00160       UNS8 res;
+00161       driver_data* data = (driver_data*)fd0;
+00162       LeaveMutex();
+00163       res = (*s_driver_procs.m_canSend)(data->inst, m);      
+00164       EnterMutex();
+00165       if (res)
+00166          return 0;
+00167       }
+00168    return 1;
+00169    }
+00170 
+00171 /***************************************************************************/
+00172 CAN_HANDLE canOpen(s_BOARD *board, CO_Data * d)
+00173    {
+00174    if (board != NULL && s_driver_procs.m_canOpen != NULL)
+00175       {
+00176       void* inst = (*s_driver_procs.m_canOpen)(board);
+00177       if (inst != NULL)
+00178          {
+00179          driver_data* data = new driver_data;
+00180          data->d = d;
+00181          data->inst = inst;
+00182          data->continue_receive_thread = true;
+00183          CreateReceiveTask(data, &data->receive_thread, &canReceiveLoop);
+00184          EnterMutex();
+00185          d->canHandle = data;
+00186          LeaveMutex();
+00187          return data;
+00188          }
+00189       }
+00190    return NULL;
+00191    }
+00192 
+00193 /***************************************************************************/
+00194 int canClose(CO_Data * d)
+00195    {
+00196    if (s_driver_procs.m_canClose != NULL)
+00197       {
+00198                   driver_data* data;
+00199                   EnterMutex();
+00200                   if(d->canHandle != NULL){
+00201                         data = (driver_data*)d->canHandle;
+00202                         d->canHandle = NULL;
+00203                         data->continue_receive_thread = false;}
+00204                   LeaveMutex();
+00205                   WaitReceiveTaskEnd(&data->receive_thread);
+00206                   (*s_driver_procs.m_canClose)(data->inst);
+00207                   delete data;
+00208                   return 0;
+00209       }
+00210    return 0;
+00211    }
+00212 
+00213 
+
drivers_win32.cpp
