1

/*

     2

This file is part of CanFestival, a library implementing CanOpen Stack.

     3

     4

Copyright (C): Edouard TISSERANT and Francis DUPIN

     5

Modified by: Jaroslav Fojtik

     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

#if defined(WIN32) && !defined(__CYGWIN__)

    25

#define usleep(micro) Sleep(micro%1000 ? (micro/1000) + 1 : (micro/1000))

    26

#else

    27

#include <stdio.h>

    28

#include <string.h>

    29

#include <errno.h>

    30

#include <fcntl.h>

    31

#endif

    32

    33

#include "cancfg.h"

    34

#include "can_driver.h"

    35

#include "def.h"

    36

    37

    38

#define VERSION_2

    39

    40

/* dummy implementation for older version. */

    41

#ifndef VERSION_2

    42

void CAN_SetRcvEvent(HANDLE hEventx)

    43

{

    44

  SetEvent(hEventx);

    45

}

    46

#endif

    47

    48

    49

    50

    51

#ifndef extra_PCAN_init_params

    52

	#define extra_PCAN_init_params /**/

    53

#else

    54

	long int print_getenv(const char* pcanparam)

    55

	{

    56

		char* param=NULL;

    57

		long int res=0;

    58

    59

		param = getenv(pcanparam);

    60

		if(param != NULL){

    61

			res = strtol(param,NULL,0);

    62

		}

    63

		else

    64

			printf("Environment variable %s not defined !\n", pcanparam);

    65

		printf("Found environment variable %s : %ld\n", pcanparam ,res);

    66

		return res;

    67

	}

    68

	#define extra_PCAN_init_params\

    69

		,print_getenv("PCANHwType")\

    70

		,print_getenv("PCANIO_Port")\

    71

		,print_getenv("PCANInterupt")

    72

#endif

    73

    74

    75

static s_BOARD *first_board = NULL;

    76

//Create the Event for the first board

    77

HANDLE hEvent1 = NULL;

    78

CRITICAL_SECTION InitLock1;

    79

CRITICAL_SECTION InitLock2;

    80

    81

    82

#ifdef PCAN2_HEADER_

    83

  static s_BOARD *second_board = NULL;

    84

  HANDLE hEvent2 = NULL;

    85

#endif

    86

    87

// Define for rtr CAN message

    88

#define CAN_INIT_TYPE_ST_RTR MSGTYPE_STANDARD | MSGTYPE_RTR

    89

    90

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

    91

static int TranslateBaudeRate(char* optarg)

    92

{

    93

	if(!strcmp( optarg, "1M")) return CAN_BAUD_1M;

    94

	if(!strcmp( optarg, "500K")) return CAN_BAUD_500K;

    95

	if(!strcmp( optarg, "250K")) return CAN_BAUD_250K;

    96

	if(!strcmp( optarg, "125K")) return CAN_BAUD_125K;

    97

	if(!strcmp( optarg, "100K")) return CAN_BAUD_100K;

    98

	if(!strcmp( optarg, "50K")) return CAN_BAUD_50K;

    99

	if(!strcmp( optarg, "20K")) return CAN_BAUD_20K;

   100

	if(!strcmp( optarg, "10K")) return CAN_BAUD_10K;

   101

	if(!strcmp( optarg, "5K")) return CAN_BAUD_5K;

   102

	if(!strcmp( optarg, "none")) return 0;

   103

	return 0x0000;

   104

}

   105

   106

static UNS8 canInit (s_BOARD *board)

   107

{

   108

	int baudrate;

   109

	int ret = 0;

   110

   111

#ifdef PCAN2_HEADER_

   112

	// if not the first handler

   113

	if(second_board == (s_BOARD *)board) {

   114

		if(hEvent2==NULL)

   115

		{	/* Create the Event for the first board */

   116

		  hEvent2 = CreateEvent(NULL, // lpEventAttributes

   117

							FALSE,  // bManualReset

   118

							FALSE,  // bInitialState

   119

							"");    // lpName

   120

		  InitializeCriticalSection(&InitLock2);

   121

		}

   122

   123

		EnterCriticalSection(&InitLock2);

   124

		if(baudrate = TranslateBaudeRate(board->baudrate))

   125

		{

   126

		  ret = CAN2_Init(baudrate, CAN_INIT_TYPE_ST extra_PCAN_init_params);

   127

		  if(ret != CAN_ERR_OK)

   128

		  {

   129

		    LeaveCriticalSection(&InitLock2);

   130

		    return 0;

   131

		  }

   132

		}

   133

		//Set Event Handle for CANReadExt

   134

		CAN2_SetRcvEvent(hEvent2);

   135

		LeaveCriticalSection(&InitLock2);

   136

	}

   137

	else

   138

#endif

   139

	if(first_board == (s_BOARD *)board) {

   140

		//Create the Event for the first board

   141

		if(hEvent1==NULL)

   142

		{

   143

		  hEvent1 = CreateEvent(NULL, // lpEventAttributes

   144

							FALSE,  // bManualReset

   145

							FALSE,  // bInitialState

   146

							"");    // lpName

   147

		  InitializeCriticalSection(&InitLock1);

   148

                }

   149

   150

		EnterCriticalSection(&InitLock1);

   151

		if(baudrate = TranslateBaudeRate(board->baudrate))

   152

		{

   153

		  ret = CAN_Init(baudrate, CAN_INIT_TYPE_ST extra_PCAN_init_params);

   154

		  if(ret != CAN_ERR_OK)

   155

		  {

   156

		    LeaveCriticalSection(&InitLock1);

   157

		    return 0;

   158

		  }

   159

		}

   160

		//Set Event Handle for CANReadExt

   161

		CAN_SetRcvEvent(hEvent1);

   162

		LeaveCriticalSection(&InitLock1);

   163

	}

   164

	return 1;

   165

}

   166

   167

/********* functions which permit to communicate with the board ****************/

   168

UNS8 LIBAPI canReceive_driver(CAN_HANDLE fd0, Message * m)

   169

{

   170

static int HeavyCounter = 0;

   171

	int ret=0;

   172

	UNS8 data;

   173

	TPCANMsg peakMsg;

   174

#ifdef CAN_READ_EX

   175

	TPCANTimestamp peakRcvTime;

   176

#endif

   177

	DWORD Res;

   178

	DWORD result;

   179

	// loop until valid message or fatal error

   180

	do{

   181

#ifdef PCAN2_HEADER_

   182

		// if not the first handler

   183

		if(second_board == (s_BOARD *)fd0) {

   184

			//wait for CAN msg...

   185

			result = WaitForSingleObject(hEvent2, INFINITE);

   186

			if (result == WAIT_OBJECT_0)

   187

				Res = CAN2_ReadEx(&peakMsg, &peakRcvTime);

   188

				// Exit receive thread when handle is no more valid

   189

				if(Res & CAN_ERRMASK_ILLHANDLE)

   190

					return 1;

   191

		}

   192

		else

   193

#endif

   194

   195

		// We read the queue looking for messages.

   196

		if(first_board == (s_BOARD *)fd0) 

   197

		{

   198

#ifdef VERSION_2

   199

			result = WaitForSingleObject(hEvent1, INFINITE);

   200

			if (result == WAIT_OBJECT_0)

   201

#endif

   202

			{

   203

#ifdef CAN_READ_EX

   204

				Res = CAN_ReadEx(&peakMsg, &peakRcvTime);

   205

#else

   206

				Res = CAN_Read(&peakMsg);

   207

#endif

   208

				// Exit receive thread when handle is no more valid

   209

#ifdef CAN_ERRMASK_ILLHANDLE

   210

				if(Res & CAN_ERRMASK_ILLHANDLE) return 1;

   211

#else

   212

				if(Res & CAN_ERR_ILLHANDLE) return 1;

   213

#endif				

   214

   215

#ifndef VERSION_2

   216

				if(Res != CAN_ERR_OK) 

   217

					result = WaitForSingleObject(hEvent1, 1);  	//pooling

   218

#endif

   219

			}

   220

		}

   221

#ifdef VERSION_2

   222

		else

   223

			Res = CAN_ERR_BUSOFF;

   224

#endif

   225

   226

		// A message was received : we process the message(s)

   227

		if(Res == CAN_ERR_OK)

   228

		{			

   229

		  switch(peakMsg.MSGTYPE)

   230

		  {

   231

		    case MSGTYPE_STATUS:

   232

			  switch(peakMsg.DATA[3])

   233

		          {

   234

			    case CAN_ERR_BUSHEAVY: 

   235

				      break;

   236

		            case CAN_ERR_BUSOFF: 

   237

			              printf ("Peak board read BUSOFF: re-init!!!\n");

   238

				      canInit((s_BOARD*)fd0);

   239

				      usleep(33);

   240

				      break;

   241

			  }

   242

			  return peakMsg.DATA[3];	/* if something different that 11bit or rtr... problem */

   243

   244

		    case MSGTYPE_STANDARD:		/* bits of MSGTYPE_ */

   245

		    case MSGTYPE_EXTENDED:

   246

			  m->rtr = 0;

   247

			  break;

   248

   249

		    case MSGTYPE_RTR:			/* bits of MSGTYPE_ */

   250

			  m->rtr = 1;

   251

			  break;

   252

   253

		    default: return CAN_ERR_OVERRUN;	/* If status, return status if 29bit, return overrun. */

   254

   255

		    }

   256

   257

		   m->cob_id = peakMsg.ID;				

   258

		   if (peakMsg.MSGTYPE == CAN_INIT_TYPE_ST)  /* bits of MSGTYPE_ */

   259

                     m->rtr = 0;

   260

		   else

   261

		     m->rtr = 1;

   262

		   m->len = peakMsg.LEN;		/* count of data bytes (0..8) */

   263

		   for (data = 0; data < peakMsg.LEN; data++)

   264

			m->data[data] = peakMsg.DATA[data];	/* data bytes, up to 8 */

   265

#if defined DEBUG_MSG_CONSOLE_ON

   266

			MSG("in : ");

   267

			print_message(m);

   268

#endif

   269

		}

   270

		else

   271

		{

   272

			// not benign error => fatal error

   273

			if (!(Res & CAN_ERR_QRCVEMPTY

   274

					|| Res & CAN_ERR_BUSLIGHT

   275

					|| Res & CAN_ERR_BUSHEAVY))

   276

			{

   277

				printf ("canReceive returned error (%d)\n", Res);

   278

				return 1;

   279

			}

   280

		}

   281

	} while(Res != CAN_ERR_OK);

   282

	return 0;

   283

}

   284

   285

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

   286

UNS8 LIBAPI canSend_driver(CAN_HANDLE fd0, Message const *m)

   287

{

   288

	UNS8 data;

   289

	TPCANMsg peakMsg;

   290

	peakMsg.ID = m->cob_id;	/* 11/29 bit code */

   291

	if (m->rtr == 0)

   292

	{

   293

	  if(peakMsg.ID > 0x7FF)

   294

		peakMsg.MSGTYPE = MSGTYPE_EXTENDED;	/* bits of MSGTYPE_ */

   295

	  else

   296

		peakMsg.MSGTYPE = MSGTYPE_STANDARD;	/* bits of MSGTYPE_ */

   297

	}

   298

	else	

   299

		peakMsg.MSGTYPE = MSGTYPE_RTR;		/* bits of MSGTYPE_ */

   300

   301

	peakMsg.LEN = m->len;

   302

	/* count of data bytes (0..8) */

   303

	for (data = 0; data < m->len; data++)

   304

		peakMsg.DATA[data] = m->data[data];	/* data bytes, up to 8 */

   305

   306

	do

   307

	{

   308

#ifdef PCAN2_HEADER_

   309

		// if not the first handler

   310

		if(second_board == (s_BOARD *)fd0)

   311

		{

   312

			errno = CAN2_Write (&peakMsg);

   313

		}

   314

		else

   315

#endif

   316

		if(first_board == (s_BOARD *)fd0)

   317

			{

   318

				errno = CAN_Write (&peakMsg);

   319

			}

   320

		else

   321

			goto fail;

   322

		if (errno)

   323

		{

   324

			if (errno == CAN_ERR_BUSOFF)

   325

			{

   326

				printf ("!!! Peak board write : re-init\n");

   327

				canInit((s_BOARD*)fd0);

   328

				usleep (10000);

   329

			}

   330

			usleep (1000);

   331

		}

   332

	}

   333

	while (errno != CAN_ERR_OK);

   334

#if defined DEBUG_MSG_CONSOLE_ON

   335

	MSG("out : ");

   336

	print_message(m);

   337

#endif

   338

	return 0;

   339

fail:

   340

	return 1;

   341

}

   342

   343

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

   344

UNS8 LIBAPI canChangeBaudRate_driver(CAN_HANDLE fd, char* baud)

   345

{

   346

	printf("canChangeBaudRate not yet supported by this driver\n");

   347

	return 0;

   348

}

   349

   350

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

   351

LIBPUBLIC CAN_HANDLE LIBAPI canOpen_driver(s_BOARD * board)

   352

{

   353

  char* pEnd;

   354

  int ret;

   355

   356

  //printf ("Board Busname=%d.\n",strtol(board->busname, &pEnd,0));

   357

  if (strtol(board->busname, &pEnd,0) == 0)

   358

  {

   359

      first_board = board;

   360

      //printf ("First Board selected\n");

   361

      ret = canInit(board);

   362

      if(ret)

   363

    	  return (CAN_HANDLE)board;

   364

  }

   365

  #ifdef PCAN2_HEADER_

   366

  if (strtol(board->busname, &pEnd,0) == 1)

   367

  {

   368

      second_board = board;

   369

      //printf ("Second Board selected\n");

   370

      ret = canInit(board);

   371

      if(ret)

   372

    	  return (CAN_HANDLE)board;

   373

  }

   374

  #endif

   375

  return NULL;

   376

}

   377

   378

   379

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

   380

int LIBAPI canClose_driver(CAN_HANDLE fd0)

   381

{

   382

#ifdef PCAN2_HEADER_

   383

	// if not the first handler

   384

	if(second_board == (s_BOARD *)fd0)

   385

	{

   386

		CAN2_SetRcvEvent(NULL);

   387

		CAN2_Close ();		

   388

		if(hEvent2)

   389

		{

   390

		  SetEvent(hEvent2);

   391

		  CloseHandle(hEvent2);		

   392

		  hEvent2 = NULL;

   393

		}

   394

		second_board = (s_BOARD *)NULL;

   395

	}else

   396

#endif

   397

	if(first_board == (s_BOARD *)fd0)

   398

	{

   399

		CAN_SetRcvEvent(NULL);

   400

		CAN_Close ();		

   401

		if(hEvent1) 

   402

		{

   403

                  SetEvent(hEvent1);

   404

		  CloseHandle(hEvent1);

   405

		  hEvent1 = NULL;

   406

                }

   407

		first_board = (s_BOARD *)NULL;

   408

	}

   409

	return 0;

   410

}