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

		if(hEvent2 != NULL){

   104

			hEvent2 = CreateEvent(NULL, // lpEventAttributes

   105

			                      FALSE,  // bManualReset

   106

			                      FALSE,  // bInitialState

   107

			                      "");    // lpName

   108

		}

   109

		//Set Event Handle for CANReadExt

   110

		CAN2_SetRcvEvent(hEvent2);

   111

	}

   112

	else

   113

#endif

   114

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

   115

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

   116

		{

   117

			ret = CAN_Init(baudrate, CAN_INIT_TYPE_ST extra_PCAN_init_params);

   118

			if(ret != CAN_ERR_OK)

   119

				return 0;

   120

		}

   121

		//Create the Event for the first board

   122

		if(hEvent1 != NULL){

   123

			hEvent1 = CreateEvent(NULL, // lpEventAttributes

   124

			                      FALSE,  // bManualReset

   125

			                      FALSE,  // bInitialState

   126

			                      "");    // lpName

   127

		}

   128

		//Set Event Handle for CANReadExt

   129

		CAN_SetRcvEvent(hEvent1);

   130

	}

   131

	return 1;

   132

}

   133

   134

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

   135

UNS8 __stdcall canReceive_driver (CAN_HANDLE fd0, Message * m)

   136

{

   137

	int ret=0;

   138

	UNS8 data;

   139

	TPCANMsg peakMsg;

   140

	TPCANTimestamp peakRcvTime;

   141

	DWORD Res;

   142

	DWORD result;

   143

	// loop until valid message or fatal error

   144

	do{

   145

#ifdef PCAN2_HEADER_

   146

		// if not the first handler

   147

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

   148

			//wait for CAN msg...

   149

			result = WaitForSingleObject(hEvent2, INFINITE);

   150

			if (result == WAIT_OBJECT_0)

   151

				Res = CAN2_ReadEx(&peakMsg, &peakRcvTime);

   152

				// Exit receive thread when handle is no more valid

   153

				if(Res & CAN_ERRMASK_ILLHANDLE)

   154

					return 1;

   155

		}

   156

		else

   157

#endif

   158

   159

		// We read the queue looking for messages.

   160

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

   161

			result = WaitForSingleObject(hEvent1, INFINITE);

   162

			if (result == WAIT_OBJECT_0)

   163

			{

   164

				Res = CAN_ReadEx(&peakMsg, &peakRcvTime);

   165

				// Exit receive thread when handle is no more valid

   166

				if(Res & CAN_ERRMASK_ILLHANDLE)

   167

					return 1;

   168

			}

   169

		}

   170

		else

   171

			Res = CAN_ERR_BUSOFF;

   172

   173

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

   174

		if (Res == CAN_ERR_OK)

   175

		{

   176

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

   177

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

   178

			{

   179

				if (peakMsg.MSGTYPE == CAN_ERR_BUSOFF)

   180

				{

   181

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

   182

					canInit((s_BOARD*) fd0);

   183

					usleep (10000);

   184

				}

   185

   186

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

   187

				return peakMsg.MSGTYPE ==

   188

					MSGTYPE_STATUS ? peakMsg.DATA[2] : CAN_ERR_OVERRUN;

   189

			}

   190

			m->cob_id = peakMsg.ID;

   191

   192

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

   193

				m->rtr = 0;

   194

			else

   195

				m->rtr = 1;

   196

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

   197

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

   198

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

   199

#if defined DEBUG_MSG_CONSOLE_ON

   200

			MSG("in : ");

   201

			print_message(m);

   202

#endif

   203

		}

   204

		else

   205

		{

   206

			// not benign error => fatal error

   207

			if (!(Res & CAN_ERR_QRCVEMPTY

   208

					|| Res & CAN_ERR_BUSLIGHT

   209

					|| Res & CAN_ERR_BUSHEAVY))

   210

			{

   211

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

   212

				return 1;

   213

			}

   214

		}

   215

	}while(Res != CAN_ERR_OK);

   216

	return 0;

   217

}

   218

   219

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

   220

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

   221

{

   222

	UNS8 data;

   223

	DWORD localerrno;

   224

	TPCANMsg peakMsg;

   225

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

   226

	if (m->rtr == 0)

   227

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

   228

	else

   229

	{

   230

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

   231

	}

   232

	peakMsg.LEN = m->len;

   233

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

   234

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

   235

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

   236

   237

	do

   238

	{

   239

#ifdef PCAN2_HEADER_

   240

		// if not the first handler

   241

		if(second_board == (s_BOARD *)fd0)

   242

		{

   243

			errno = localerrno = CAN2_Write (&peakMsg);

   244

		}

   245

		else

   246

#endif

   247

		if(first_board == (s_BOARD *)fd0)

   248

			{

   249

				errno = localerrno = CAN_Write (&peakMsg);

   250

			}

   251

		else

   252

			goto fail;

   253

		if (localerrno)

   254

		{

   255

			if (localerrno == CAN_ERR_BUSOFF)

   256

			{

   257

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

   258

				canInit((s_BOARD*)fd0);

   259

				usleep (10000);

   260

			}

   261

			usleep (1000);

   262

		}

   263

	}

   264

	while (localerrno != CAN_ERR_OK);

   265

#if defined DEBUG_MSG_CONSOLE_ON

   266

	MSG("out : ");

   267

	print_message(m);

   268

#endif

   269

	return 0;

   270

fail:

   271

	return 1;

   272

}

   273

   274

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

   275

UNS8 __stdcall canChangeBaudRate_driver( CAN_HANDLE fd, char* baud)

   276

{

   277

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

   278

	return 0;

   279

}

   280

   281

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

   282

CAN_HANDLE __stdcall canOpen_driver (s_BOARD * board)

   283

{

   284

  char busname[64];

   285

  char* pEnd;

   286

  int ret;

   287

   288

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

   289

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

   290

  {

   291

      first_board = board;

   292

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

   293

      ret = canInit(board);

   294

      if(ret)

   295

    	  return (CAN_HANDLE)board;

   296

  }

   297

  #ifdef PCAN2_HEADER_

   298

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

   299

  {

   300

      second_board = board;

   301

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

   302

      ret = canInit(board);

   303

      if(ret)

   304

    	  return (CAN_HANDLE)board;

   305

  }

   306

  #endif

   307

  return NULL;

   308

}

   309

   310

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

   311

int __stdcall canClose_driver (CAN_HANDLE fd0)

   312

{

   313

#ifdef PCAN2_HEADER_

   314

      // if not the first handler

   315

      if(second_board == (s_BOARD *)fd0)

   316

      {

   317

           CAN2_SetRcvEvent(NULL);

   318

           CAN2_Close ();

   319

           if(hEvent2)

   320

           {

   321

             SetEvent(hEvent2);

   322

             CloseHandle(hEvent2);

   323

             hEvent2 = NULL;

   324

           }

   325

           second_board = (s_BOARD *)NULL;

   326

      }else

   327

#endif

   328

      if(first_board == (s_BOARD *)fd0)

   329

      {

   330

           CAN_SetRcvEvent(NULL);

   331

           CAN_Close ();

   332

           if(hEvent1)

   333

           {

   334

             SetEvent(hEvent1);

   335

             CloseHandle(hEvent1);

   336

             hEvent1 = NULL;

   337

            }

   338

           first_board = (s_BOARD *)NULL;

   339

      }

   340

      return 0;

   341

}