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

/*

    25

 CAN driver interface.

    26

*/

    27

    28

#include <windows.h>

    29

    30

#ifdef __cplusplus

    31

extern "C" {

    32

#endif

    33

    34

#include "canfestival.h"

    35

#include "timer.h"

    36

#include "timers_driver.h"

    37

    38

#ifdef __cplusplus

    39

};

    40

#endif

    41

    42

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

    43

#ifdef UNDER_CE

    44

  #define myTEXT(str) TEXT(str)

    45

#else

    46

  #define myTEXT(str) str

    47

#endif

    48

    49

#define MAX_NB_CAN_PORTS 16

    50

    51

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

    52

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

    53

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

    54

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

    55

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

    56

    57

CANRECEIVE_DRIVER_PROC m_canReceive;

    58

CANSEND_DRIVER_PROC m_canSend;

    59

CANOPEN_DRIVER_PROC m_canOpen;

    60

CANCLOSE_DRIVER_PROC m_canClose;

    61

CANCHANGEBAUDRATE_DRIVER_PROC m_canChangeBaudRate;

    62

    63

/* CAN port structure */

    64

typedef struct

    65

{

    66

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

    67

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

    68

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

    69

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

    70

}CANPort;

    71

    72

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

    73

    74

    75

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

    76

UNS8 UnLoadCanDriver(LIB_HANDLE handle)

    77

{

    78

#ifndef NOT_USE_DYNAMIC_LOADING

    79

	if(handle != NULL)

    80

	{

    81

		FreeLibrary(handle);

    82

		handle=NULL;

    83

		return 0;

    84

	}

    85

	return -1;

    86

#else

    87

  handle = NULL;

    88

  return 0;

    89

#endif //NOT_USE_DYNAMIC_LOADING

    90

}

    91

    92

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

    93

/**

    94

 * Loads the dll and get funcs ptr

    95

 *

    96

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

    97

 * @return Library handle

    98

 */

    99

LIB_HANDLE LoadCanDriver(LPCTSTR driver_name)

   100

{

   101

	// driver module handle

   102

	LIB_HANDLE handle = NULL;

   103

   104

#ifndef NOT_USE_DYNAMIC_LOADING

   105

	if(handle == NULL)

   106

	{

   107

		handle = LoadLibrary(driver_name);

   108

	}

   109

   110

	if (!handle)

   111

	{

   112

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

   113

    	return NULL;

   114

	}

   115

   116

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

   117

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

   118

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

   119

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

   120

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

   121

#else

   122

  //compiled in...

   123

  handle = 1; //TODO: remove this hack

   124

   125

  m_canReceive = canReceive_driver;

   126

	m_canSend = canSend_driver;

   127

	m_canOpen = canOpen_driver;

   128

	m_canClose = canClose_driver;

   129

	m_canChangeBaudRate = canChangeBaudRate_driver;

   130

#endif

   131

   132

   133

	return handle;

   134

}

   135

   136

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

   137

UNS8 canSend(CAN_PORT port, Message *m)

   138

{

   139

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

   140

	{

   141

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

   142

	}

   143

	return 1;

   144

}

   145

   146

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

   147

void canReceiveLoop(CAN_PORT port)

   148

{

   149

	Message m;

   150

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

   151

	{

   152

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

   153

		EnterMutex();

   154

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

   155

		LeaveMutex();

   156

	}

   157

}

   158

   159

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

   160

CAN_HANDLE canOpen(s_BOARD *board, CO_Data * d)

   161

{

   162

	int i;

   163

    CAN_HANDLE fd0;

   164

   165

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

   166

	{

   167

		if(!canports[i].used)

   168

		break;

   169

	}

   170

   171

	#ifndef NOT_USE_DYNAMIC_LOADING

   172

	if (m_canOpen == NULL)

   173

	{

   174

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

   175

	   	return NULL;

   176

	}

   177

	#endif

   178

   179

	fd0 = m_canOpen(board);

   180

	if(fd0)

   181

	{

   182

		canports[i].used = 1;

   183

		canports[i].fd = fd0;

   184

		canports[i].d = d;

   185

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

   186

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

   187

		return (CAN_PORT)&canports[i];

   188

	}

   189

	else

   190

	{

   191

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

   192

		return NULL;

   193

	}

   194

}

   195

   196

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

   197

int canClose(CO_Data * d)

   198

{

   199

	UNS8 res = 1;

   200

	CANPort* tmp;

   201

   202

	if((CANPort*)d->canHandle)

   203

	{

   204

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

   205

	}

   206

   207

	tmp = (CANPort*)d->canHandle;

   208

   209

	if(tmp)

   210

	{

   211

	  // kill receiver task before port is closed and handle set to NULL

   212

	  WaitReceiveTaskEnd(&tmp->receiveTask);

   213

   214

	  // close CAN port

   215

	  res = m_canClose(tmp->fd);

   216

	}

   217

   218

	d->canHandle = NULL;

   219

   220

	return res;

   221

}

   222

   223

UNS8 canChangeBaudRate(CAN_PORT port, char* baud)

   224

{

   225

   if(port){

   226

		UNS8 res;

   227

	    //LeaveMutex();

   228

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

   229

		//EnterMutex();

   230

		return res; // OK

   231

	}

   232

	return 1; // NOT OK

   233

}

   234