1

/*

     2

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

     3

     4

Copyright (C): Edouard TISSERANT and Francis DUPIN

     5

     6

See COPYING file for copyrights details.

     7

     8

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

     9

modify it under the terms of the GNU Lesser General Public

    10

License as published by the Free Software Foundation; either

    11

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

    12

    13

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

    14

but WITHOUT ANY WARRANTY; without even the implied warranty of

    15

MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

    16

Lesser General Public License for more details.

    17

    18

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

    19

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

    20

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

    21

*/

    22

    23

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

    24

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

    25

#else

    26

#include <stdio.h>

    27

#include <string.h>

    28

#include <errno.h>

    29

#include <fcntl.h>

    30

#endif

    31

    32

#include "cancfg.h"

    33

#include "can_driver.h"

    34

#include "def.h"

    35

#ifndef extra_PCAN_init_params

    36

	#define extra_PCAN_init_params /**/

    37

#else

    38

	long int print_getenv(const char* pcanparam)

    39

	{

    40

		char* param=NULL;

    41

		long int res=0;

    42

    43

		param = getenv(pcanparam);

    44

		if(param != NULL){

    45

			res = strtol(param,NULL,0);

    46

		}

    47

		else

    48

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

    49

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

    50

		return res;

    51

	}

    52

	#define extra_PCAN_init_params\

    53

		,print_getenv("PCANHwType")\

    54

		,print_getenv("PCANIO_Port")\

    55

		,print_getenv("PCANInterupt")

    56

#endif

    57

    58

static s_BOARD *first_board = NULL;

    59

    60

//Create the Event for the first board

    61

HANDLE hEvent1 = NULL;

    62

    63

    64

#ifdef PCAN2_HEADER_

    65

	static s_BOARD *second_board = NULL;

    66

	HANDLE hEvent2 = NULL;

    67

#endif

    68

    69

// Define for rtr CAN message

    70

#define CAN_INIT_TYPE_ST_RTR MSGTYPE_STANDARD | MSGTYPE_RTR

    71

    72

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

    73

int TranslateBaudeRate(char* optarg){

    74

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

    75

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

    76

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

    77

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

    78

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

    79

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

    80

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

    81

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

    82

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

    83

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

    84

	return 0x0000;

    85

}

    86

    87

UNS8 canInit (s_BOARD *board)

    88

{

    89

	int baudrate;

    90

	int ret = 0;

    91

    92

#ifdef PCAN2_HEADER_

    93

	// if not the first handler

    94

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

    95

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

    96

		{

    97

			ret = CAN2_Init(baudrate, CAN_INIT_TYPE_ST extra_PCAN_init_params);

    98

			if(ret != CAN_ERR_OK)

    99

				return 0;

   100

		}

   101

   102

		//Create the Event for the first board

   103

		hEvent2 = CreateEvent(NULL, // lpEventAttributes

   104

							FALSE,  // bManualReset

   105

							FALSE,  // bInitialState

   106

							"");    // lpName

   107

   108

		//Set Event Handle for CANReadExt

   109

		CAN2_SetRcvEvent(hEvent2);

   110

	}

   111

	else

   112

#endif

   113

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

   114

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

   115

		{

   116

			ret = CAN_Init(baudrate, CAN_INIT_TYPE_ST extra_PCAN_init_params);

   117

			if(ret != CAN_ERR_OK)

   118

				return 0;

   119

		}

   120

		//Create the Event for the first board

   121

		hEvent1 = CreateEvent(NULL, // lpEventAttributes

   122

							FALSE,  // bManualReset

   123

							FALSE,  // bInitialState

   124

							"");    // lpName

   125

		//Set Event Handle for CANReadExt

   126

		CAN_SetRcvEvent(hEvent1);

   127

	}

   128

	return 1;

   129

}

   130

   131

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

   132

UNS8 canReceive_driver (CAN_HANDLE fd0, Message * m)

   133

{

   134

	int ret=0;

   135

	UNS8 data;

   136

	TPCANMsg peakMsg;

   137

	TPCANTimestamp peakRcvTime;

   138

	DWORD Res;

   139

	DWORD result;

   140

	// loop until valid message or fatal error

   141

	do{

   142

#ifdef PCAN2_HEADER_

   143

		// if not the first handler

   144

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

   145

			//wait for CAN msg...

   146

			result = WaitForSingleObject(hEvent2, INFINITE);

   147

			if (result == WAIT_OBJECT_0)

   148

				Res = CAN2_ReadEx(&peakMsg, &peakRcvTime);

   149

				// Exit receive thread when handle is no more valid

   150

				if(Res & CAN_ERRMASK_ILLHANDLE)

   151

					return 1;

   152

		}

   153

		else

   154

#endif

   155

   156

		// We read the queue looking for messages.

   157

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

   158

			result = WaitForSingleObject(hEvent1, INFINITE);

   159

			if (result == WAIT_OBJECT_0)

   160

			{

   161

				Res = CAN_ReadEx(&peakMsg, &peakRcvTime);

   162

				// Exit receive thread when handle is no more valid

   163

				if(Res & CAN_ERRMASK_ILLHANDLE)

   164

					return 1;

   165

			}

   166

		}

   167

		else

   168

			Res = CAN_ERR_BUSOFF;

   169

   170

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

   171

		if (Res == CAN_ERR_OK)

   172

		{

   173

			// if something different that 11bit or rtr... problem

   174

			if (peakMsg.MSGTYPE & ~(MSGTYPE_STANDARD | MSGTYPE_RTR))

   175

			{

   176

				if (peakMsg.MSGTYPE == CAN_ERR_BUSOFF)

   177

				{

   178

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

   179

					canInit((s_BOARD*) fd0);

   180

					usleep (10000);

   181

				}

   182

   183

				// If status, return status if 29bit, return overrun

   184

				return peakMsg.MSGTYPE ==

   185

					MSGTYPE_STATUS ? peakMsg.DATA[2] : CAN_ERR_OVERRUN;

   186

			}

   187

			m->cob_id = peakMsg.ID;

   188

   189

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

   190

				m->rtr = 0;

   191

			else

   192

				m->rtr = 1;

   193

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

   194

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

   195

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

   196

#if defined DEBUG_MSG_CONSOLE_ON

   197

			MSG("in : ");

   198

			print_message(m);

   199

#endif

   200

		}

   201

		else

   202

		{

   203

			// not benign error => fatal error

   204

			if (!(Res & CAN_ERR_QRCVEMPTY

   205

					|| Res & CAN_ERR_BUSLIGHT

   206

					|| Res & CAN_ERR_BUSHEAVY))

   207

			{

   208

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

   209

				return 1;

   210

			}

   211

		}

   212

	}while(Res != CAN_ERR_OK);

   213

	return 0;

   214

}

   215

   216

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

   217

UNS8 canSend_driver (CAN_HANDLE fd0, Message * m)

   218

{

   219

	UNS8 data;

   220

	TPCANMsg peakMsg;

   221

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

   222

	if (m->rtr == 0)

   223

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

   224

	else

   225

	{

   226

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

   227

	}

   228

	peakMsg.LEN = m->len;

   229

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

   230

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

   231

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

   232

   233

	do

   234

	{

   235

#ifdef PCAN2_HEADER_

   236

		// if not the first handler

   237

		if(second_board == (s_BOARD *)fd0)

   238

		{

   239

			errno = CAN2_Write (&peakMsg);

   240

		}

   241

		else

   242

#endif

   243

		if(first_board == (s_BOARD *)fd0)

   244

			{

   245

				errno = CAN_Write (&peakMsg);

   246

			}

   247

		else

   248

			goto fail;

   249

		if (errno)

   250

		{

   251

			if (errno == CAN_ERR_BUSOFF)

   252

			{

   253

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

   254

				canInit((s_BOARD*)fd0);

   255

				usleep (10000);

   256

			}

   257

			usleep (1000);

   258

		}

   259

	}

   260

	while (errno != CAN_ERR_OK);

   261

#if defined DEBUG_MSG_CONSOLE_ON

   262

	MSG("out : ");

   263

	print_message(m);

   264

#endif

   265

	return 0;

   266

fail:

   267

	return 1;

   268

}

   269

   270

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

   271

UNS8 canChangeBaudRate_driver( CAN_HANDLE fd, char* baud)

   272

{

   273

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

   274

	return 0;

   275

}

   276

   277

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

   278

CAN_HANDLE canOpen_driver (s_BOARD * board)

   279

{

   280

  char busname[64];

   281

  char* pEnd;

   282

  int ret;

   283

   284

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

   285

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

   286

  {

   287

      first_board = board;

   288

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

   289

      ret = canInit(board);

   290

      if(ret)

   291

    	  return (CAN_HANDLE)board;

   292

  }

   293

  #ifdef PCAN2_HEADER_

   294

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

   295

  {

   296

      second_board = board;

   297

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

   298

      ret = canInit(board);

   299

      if(ret)

   300

    	  return (CAN_HANDLE)board;

   301

  }

   302

  #endif

   303

  return NULL;

   304

}

   305

   306

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

   307

int canClose_driver (CAN_HANDLE fd0)

   308

{

   309

#ifdef PCAN2_HEADER_

   310

	// if not the first handler

   311

	if(second_board == (s_BOARD *)fd0)

   312

	{

   313

		CAN2_SetRcvEvent(NULL);

   314

		CAN2_Close ();

   315

		SetEvent(hEvent2);

   316

		second_board = (s_BOARD *)NULL;

   317

	}else

   318

#endif

   319

	if(first_board == (s_BOARD *)fd0)

   320

	{

   321

		CAN_SetRcvEvent(NULL);

   322

		CAN_Close ();

   323

		SetEvent(hEvent1);

   324

		first_board = (s_BOARD *)NULL;

   325

	}

   326

	return 0;

   327

}