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

Modified by: Jaroslav Fojtik

     7

     8

See COPYING file for copyrights details.

     9

    10

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

    11

modify it under the terms of the GNU Lesser General Public

    12

License as published by the Free Software Foundation; either

    13

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

    14

    15

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

    16

but WITHOUT ANY WARRANTY; without even the implied warranty of

    17

MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

    18

Lesser General Public License for more details.

    19

    20

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

    21

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

    22

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

    23

*/

    24

    25

/*

    26

 CAN driver interface.

    27

*/

    28

    29

#include <windows.h>

    30

    31

#ifdef __cplusplus

    32

extern "C" {

    33

#endif

    34

    35

#include "canfestival.h"

    36

#include "timer.h"

    37

#include "timers_driver.h"

    38

    39

#ifdef __cplusplus

    40

};

    41

#endif

    42

    43

// GetProcAddress doesn't have an UNICODE version for NT

    44

#ifdef UNDER_CE

    45

  #define myTEXT(str) TEXT(str)

    46

#else

    47

  #define myTEXT(str) str

    48

#endif

    49

    50

#define MAX_NB_CAN_PORTS 16

    51

    52

typedef UNS8 (CALLBACK* CANRECEIVE_DRIVER_PROC)(void* inst, Message *m);

    53

typedef UNS8 (CALLBACK* CANSEND_DRIVER_PROC)(void* inst, const Message *m);

    54

typedef void* (CALLBACK* CANOPEN_DRIVER_PROC)(s_BOARD *board);

    55

typedef int (CALLBACK* CANCLOSE_DRIVER_PROC)(void* inst);

    56

typedef UNS8 (CALLBACK* CANCHANGEBAUDRATE_DRIVER_PROC)(void* fd, char* baud);

    57

    58

CANRECEIVE_DRIVER_PROC m_canReceive;

    59

CANSEND_DRIVER_PROC m_canSend;

    60

CANOPEN_DRIVER_PROC m_canOpen;

    61

CANCLOSE_DRIVER_PROC m_canClose;

    62

CANCHANGEBAUDRATE_DRIVER_PROC m_canChangeBaudRate;

    63

    64

/* CAN port structure */

    65

typedef struct

    66

{

    67

  char used;  /**< flag indicating CAN port usage, will be used to abort Receiver task*/

    68

  CAN_HANDLE fd; /**< CAN port file descriptor*/

    69

  TASK_HANDLE receiveTask; /**< CAN Receiver task*/

    70

  CO_Data* d; /**< CAN object data*/

    71

}CANPort;

    72

    73

CANPort canports[MAX_NB_CAN_PORTS] = {{0,},{0,},{0,},{0,},{0,},{0,},{0,},{0,},{0,},{0,},{0,},{0,},{0,},{0,},{0,},{0,}};

    74

    75

    76

/***************************************************************************/

    77

UNS8 UnLoadCanDriver(LIB_HANDLE handle)

    78

{

    79

#ifndef NOT_USE_DYNAMIC_LOADING

    80

	if(handle != NULL)

    81

	{

    82

		FreeLibrary(handle);

    83

		handle=NULL;

    84

		return 0;

    85

	}

    86

	return -1;

    87

#else

    88

  handle = NULL;

    89

  return 0;

    90

#endif //NOT_USE_DYNAMIC_LOADING

    91

}

    92

    93

/***************************************************************************/

    94

/**

    95

 * Loads the dll and get funcs ptr

    96

 *

    97

 * @param driver_name String containing driver's dynamic library name

    98

 * @return Library handle

    99

 */

   100

LIB_HANDLE LoadCanDriver(LPCSTR driver_name)

   101

{

   102

    // driver module handle

   103

    LIB_HANDLE handle = NULL;

   104

   105

#ifndef NOT_USE_DYNAMIC_LOADING

   106

    handle = LoadLibrary(driver_name);

   107

   108

    if (!handle)

   109

    {

   110

        fprintf (stderr, "LoadLibrary error : %d\n", GetLastError());

   111

        return NULL;

   112

    }

   113

   114

    m_canReceive = (CANRECEIVE_DRIVER_PROC)GetProcAddress(handle, myTEXT("canReceive_driver"));

   115

    m_canSend = (CANSEND_DRIVER_PROC)GetProcAddress(handle, myTEXT("canSend_driver"));

   116

    m_canOpen = (CANOPEN_DRIVER_PROC)GetProcAddress(handle, myTEXT("canOpen_driver"));

   117

    m_canClose = (CANCLOSE_DRIVER_PROC)GetProcAddress(handle, myTEXT("canClose_driver"));

   118

    m_canChangeBaudRate = (CANCHANGEBAUDRATE_DRIVER_PROC)GetProcAddress(handle, myTEXT("canChangeBaudRate_driver"));

   119

   120

    if(m_canReceive==NULL || m_canSend==NULL || m_canOpen==NULL || m_canClose==NULL || m_canChangeBaudRate==NULL)

   121

    {

   122

        m_canReceive = NULL;

   123

        m_canSend = NULL;

   124

        m_canOpen = NULL;

   125

        m_canClose = NULL;

   126

        m_canChangeBaudRate = NULL;

   127

        FreeLibrary(handle);

   128

        fprintf (stderr, "GetProc error : %d\n", GetLastError());

   129

        return NULL;

   130

    }

   131

#else

   132

    //compiled in...

   133

    handle = 1; //TODO: remove this hack

   134

   135

    m_canReceive = canReceive_driver;

   136

    m_canSend = canSend_driver;

   137

    m_canOpen = canOpen_driver;

   138

    m_canClose = canClose_driver;

   139

    m_canChangeBaudRate = canChangeBaudRate_driver;

   140

#endif

   141

   142

   143

    return handle;

   144

}

   145

   146

/***************************************************************************/

   147

UNS8 canSend(CAN_PORT port, Message *m)

   148

{

   149

	if (port && (m_canSend != NULL))

   150

	{

   151

		return m_canSend(((CANPort*)port)->fd, m);

   152

	}

   153

	return 1; /* NOT OK */	

   154

}

   155

   156

/***************************************************************************/

   157

DWORD canReceiveLoop(CAN_PORT port)

   158

{

   159

	Message m;

   160

	while(((CANPort*)port)->used)

   161

	{

   162

		if(m_canReceive(((CANPort*)port)->fd, &m) != 0) 

   163

            break;

   164

		EnterMutex();

   165

		canDispatch(((CANPort*)port)->d, &m);

   166

		LeaveMutex();

   167

	}

   168

	return 0;

   169

}

   170

   171

/***************************************************************************/

   172

CAN_HANDLE canOpen(s_BOARD *board, CO_Data * d)

   173

{

   174

	int i;

   175

	CAN_HANDLE fd0;

   176

   177

   178

	  /* Fix of multiple opening one data set, added by J.Fojtik. */

   179

	if(d->canHandle)

   180

	{

   181

	  canClose(d);

   182

	}

   183

   184

	for(i=0; i < MAX_NB_CAN_PORTS; i++)

   185

	{

   186

		if(!canports[i].used)

   187

		break;

   188

	}

   189

   190

	#ifndef NOT_USE_DYNAMIC_LOADING

   191

	if (m_canOpen == NULL)

   192

	{

   193

	   	fprintf(stderr,"CanOpen : Can Driver dll not loaded\n");

   194

	   	return NULL;

   195

	}

   196

	#endif

   197

   198

	fd0 = m_canOpen(board);

   199

	if(fd0)

   200

	{

   201

		canports[i].used = 1;

   202

		canports[i].fd = fd0;

   203

		canports[i].d = d;

   204

		d->canHandle = (CAN_PORT)&canports[i];

   205

		CreateReceiveTask(&(canports[i]), &canports[i].receiveTask, (void *)canReceiveLoop);

   206

		return (CAN_PORT)&canports[i];

   207

	}

   208

	else

   209

	{

   210

		MSG("CanOpen : Cannot open board {busname='%S',baudrate='%S'}\n",board->busname, board->baudrate);

   211

		return NULL;

   212

	}

   213

}

   214

   215

/***************************************************************************/

   216

int canClose(CO_Data * d)

   217

{

   218

    int res = 0;

   219

   220

    CANPort* port = (CANPort*)d->canHandle;

   221

    if(port){

   222

        ((CANPort*)d->canHandle)->used = 0;

   223

   224

        res = m_canClose(port->fd);

   225

   226

        WaitReceiveTaskEnd(&port->receiveTask);

   227

   228

        d->canHandle = NULL;

   229

    }

   230

   231

    return res;

   232

}

   233

   234

UNS8 canChangeBaudRate(CAN_PORT port, char* baud)

   235

{

   236

   if(port){

   237

		UNS8 res;

   238

	    //LeaveMutex();

   239

		res = m_canChangeBaudRate(((CANPort*)port)->fd, baud);

   240

		//EnterMutex();

   241

		return res; // OK

   242

	}

   243

	return 1; // NOT OK

   244

}

   245