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"));

   132

#else

   133

  //compiled in...

   134

  handle = 1; //TODO: remove this hack

   135

   136

  m_canReceive = canReceive_driver;

   137

	m_canSend = canSend_driver;

   138

	m_canOpen = canOpen_driver;

   139

	m_canClose = canClose_driver;

   140

	m_canChangeBaudRate = canChangeBaudRate_driver;

   141

#endif

   142

   143

   144

	return handle;

   145

}

   146

   147

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

   148

UNS8 canSend(CAN_PORT port, Message *m)

   149

{

   150

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

   151

	{

   152

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

   153

	}

   155

}

   156

   157

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

   158

void canReceiveLoop(CAN_PORT port)

   159

{

   160

	Message m;

   161

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

   162

	{

   163

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

   164

		EnterMutex();

   165

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

   166

		LeaveMutex();

   167

	}

   168

}

   169

   170

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

   171

CAN_HANDLE canOpen(s_BOARD *board, CO_Data * d)

   172

{

   173

	int i;

   174

    CAN_HANDLE fd0;

   175

   176

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

   177

	{

   178

		if(!canports[i].used)

   179

		break;

   180

	}

   181

   182

	#ifndef NOT_USE_DYNAMIC_LOADING

   183

	if (m_canOpen == NULL)

   184

	{

   185

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

   186

	   	return NULL;

   187

	}

   188

	#endif

   189

   190

	fd0 = m_canOpen(board);

   191

	if(fd0)

   192

	{

   193

		canports[i].used = 1;

   194

		canports[i].fd = fd0;

   195

		canports[i].d = d;

   196

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

   197

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

   198

		return (CAN_PORT)&canports[i];

   199

	}

   200

	else

   201

	{

   202

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

   203

		return NULL;

   204

	}

   205

}

   206

   207

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

   208

int canClose(CO_Data * d)

   209

{

   210

	UNS8 res = 1;

   211

	CANPort* tmp;

   212

   213

	if((CANPort*)d->canHandle)

   214

	{

   215

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

   216

	}

   217

   218

	tmp = (CANPort*)d->canHandle;

   219

   220

	if(tmp)

   221

	{

   222

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

   223

	  WaitReceiveTaskEnd(&tmp->receiveTask);

   224

   225

	  // close CAN port

   226

	  res = m_canClose(tmp->fd);

   227

	}

   228

   229

	d->canHandle = NULL;

   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