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

	#define extra_PCAN_init_params\

    39

		,getenv("PCANHwType") ? strtol(getenv("PCANHwType"),NULL,0):0\

    40

		,getenv("PCANIO_Port") ? strtol(getenv("PCANIO_Port"),NULL,0):0\

    41

		,getenv("PCANInterupt") ? strtol(getenv("PCANInterupt"),NULL,0):0

    42

#endif

    43

    44

static s_BOARD *first_board = NULL;

    45

    46

//Create the Event for the first board

    47

HANDLE hEvent1 = NULL;

    48

    49

    50

#ifdef PCAN2_HEADER_

    51

	static s_BOARD *second_board = NULL;

    52

	HANDLE hEvent2 = NULL;

    53

#endif

    54

    55

// Define for rtr CAN message

    56

#define CAN_INIT_TYPE_ST_RTR MSGTYPE_STANDARD | MSGTYPE_RTR

    57

    58

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

    59

int TranslateBaudeRate(char* optarg){

    60

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

    61

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

    62

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

    63

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

    64

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

    65

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

    66

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

    67

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

    68

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

    69

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

    70

	return 0x0000;

    71

}

    72

    73

UNS8 canInit (s_BOARD *board)

    74

{

    75

	int baudrate;

    76

	int ret = 0;

    77

    78

#ifdef PCAN2_HEADER_

    79

	// if not the first handler

    80

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

    81

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

    82

		{

    83

			ret = CAN2_Init(baudrate, CAN_INIT_TYPE_ST extra_PCAN_init_params);

    84

			if(ret != CAN_ERR_OK)

    85

				return 0;

    86

		}

    87

    88

		//Create the Event for the first board

    89

		hEvent2 = CreateEvent(NULL, // lpEventAttributes

    90

							FALSE,  // bManualReset

    91

							FALSE,  // bInitialState

    92

							"");    // lpName

    93

    94

		//Set Event Handle for CANReadExt

    95

		CAN2_SetRcvEvent(hEvent2);

    96

	}

    97

	else

    98

#endif

    99

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

   100

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

   101

		{

   102

			ret = CAN_Init(baudrate, CAN_INIT_TYPE_ST extra_PCAN_init_params);

   103

			if(ret != CAN_ERR_OK)

   104

				return 0;

   105

		}

   106

		//Create the Event for the first board

   107

		hEvent1 = CreateEvent(NULL, // lpEventAttributes

   108

							FALSE,  // bManualReset

   109

							FALSE,  // bInitialState

   110

							"");    // lpName

   111

		//Set Event Handle for CANReadExt

   112

		CAN_SetRcvEvent(hEvent1);

   113

	}

   114

	return 1;

   115

}

   116

   117

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

   118

UNS8 canReceive_driver (CAN_HANDLE fd0, Message * m)

   119

{

   120

	int ret=0;

   121

	UNS8 data;

   122

	TPCANMsg peakMsg;

   123

	TPCANTimestamp peakRcvTime;

   124

	DWORD Res;

   125

	DWORD result;

   126

   127

#ifdef PCAN2_HEADER_

   128

	// if not the first handler

   129

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

   130

		//wait for CAN msg...

   131

		result = WaitForSingleObject(hEvent2, INFINITE);

   132

		if (result == WAIT_OBJECT_0)

   133

			Res = CAN2_ReadEx(&peakMsg, &peakRcvTime);

   134

			if(Res == (CAN_ERR_QRCVEMPTY | CAN_ERRMASK_ILLHANDLE))

   135

			{

   136

				ResetEvent(hEvent2);

   137

				return 1;

   138

			}

   139

	}

   140

	else

   141

#endif

   142

   143

	// We read the queue looking for messages.

   144

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

   145

		result = WaitForSingleObject(hEvent1, INFINITE);

   146

		if (result == WAIT_OBJECT_0)

   147

		{

   148

			Res = CAN_ReadEx(&peakMsg, &peakRcvTime);

   149

			if(Res == (CAN_ERR_QRCVEMPTY | CAN_ERRMASK_ILLHANDLE))

   150

			{

   151

				ResetEvent(hEvent1);

   152

				return 1;

   153

			}

   154

		}

   155

	}

   156

	else

   157

		Res = CAN_ERR_BUSOFF;

   158

   159

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

   160

	if (Res == CAN_ERR_OK)

   161

	{

   162

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

   163

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

   164

		{

   165

			if (peakMsg.MSGTYPE == CAN_ERR_BUSOFF)

   166

			{

   167

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

   168

				canInit((s_BOARD*) fd0);

   169

				usleep (10000);

   170

			}

   171

   172

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

   173

			return peakMsg.MSGTYPE ==

   174

				MSGTYPE_STATUS ? peakMsg.DATA[2] : CAN_ERR_OVERRUN;

   175

		}

   176

		m->cob_id = peakMsg.ID;

   177

   178

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

   179

			m->rtr = 0;

   180

		else

   181

			m->rtr = 1;

   182

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

   183

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

   184

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

   185

#if defined DEBUG_MSG_CONSOLE_ON

   186

		MSG("in : ");

   187

		print_message(m);

   188

#endif

   189

	}

   190

	else

   191

	{

   192

		if (!(Res & CAN_ERR_QRCVEMPTY

   193

				|| Res & CAN_ERR_BUSLIGHT

   194

				|| Res & CAN_ERR_BUSHEAVY))

   195

		{

   196

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

   197

			return 1;

   198

		}

   199

	}

   200

	return 0;

   201

}

   202

   203

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

   204

UNS8 canSend_driver (CAN_HANDLE fd0, Message * m)

   205

{

   206

	UNS8 data;

   207

	TPCANMsg peakMsg;

   208

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

   209

	if (m->rtr == 0)

   210

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

   211

	else

   212

	{

   213

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

   214

	}

   215

	peakMsg.LEN = m->len;

   216

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

   217

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

   218

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

   219

   220

	do

   221

	{

   222

#ifdef PCAN2_HEADER_

   223

		// if not the first handler

   224

		if(second_board == (s_BOARD *)fd0)

   225

		{

   226

			errno = CAN2_Write (&peakMsg);

   227

		}

   228

		else

   229

#endif

   230

		if(first_board == (s_BOARD *)fd0)

   231

			{

   232

				errno = CAN_Write (&peakMsg);

   233

			}

   234

		else

   235

			goto fail;

   236

		if (errno)

   237

		{

   238

			if (errno == CAN_ERR_BUSOFF)

   239

			{

   240

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

   241

				canInit((s_BOARD*)fd0);

   242

				usleep (10000);

   243

			}

   244

			usleep (1000);

   245

		}

   246

	}

   247

	while (errno != CAN_ERR_OK);

   248

#if defined DEBUG_MSG_CONSOLE_ON

   249

	MSG("out : ");

   250

	print_message(m);

   251

#endif

   252

	return 0;

   253

fail:

   254

	return 1;

   255

}

   256

   257

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

   258

UNS8 canChangeBaudRate_driver( CAN_HANDLE fd, char* baud)

   259

{

   260

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

   261

	return 0;

   262

}

   263

   264

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

   265

CAN_HANDLE canOpen_driver (s_BOARD * board)

   266

{

   267

  char busname[64];

   268

  char* pEnd;

   269

  int ret;

   270

   271

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

   272

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

   273

  {

   274

      first_board = board;

   275

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

   276

      ret = canInit(board);

   277

      if(ret)

   278

    	  return (CAN_HANDLE)board;

   279

  }

   280

  #ifdef PCAN2_HEADER_

   281

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

   282

  {

   283

      second_board = board;

   284

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

   285

      ret = canInit(board);

   286

      if(ret)

   287

    	  return (CAN_HANDLE)board;

   288

  }

   289

  #endif

   290

  return NULL;

   291

}

   292

   293

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

   294

int canClose_driver (CAN_HANDLE fd0)

   295

{

   296

#ifdef PCAN2_HEADER_

   297

	// if not the first handler

   298

	if(second_board == (s_BOARD *)fd0)

   299

	{

   300

		SetEvent(hEvent2);

   301

		CAN2_Close ();

   302

		second_board = (s_BOARD *)NULL;

   303

	}else

   304

#endif

   305

	if(first_board == (s_BOARD *)fd0)

   306

	{

   307

		SetEvent(hEvent1);

   308

		CAN_Close ();

   309

		first_board = (s_BOARD *)NULL;

   310

	}

   311

	return 0;

   312

}