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

#ifdef PCAN2_HEADER_

    46

static s_BOARD *second_board = NULL;

    47

#endif

    48

    49

//pthread_mutex_t PeakCan_mutex = PTHREAD_MUTEX_INITIALIZER;

    50

    51

// Define for rtr CAN message

    52

#define CAN_INIT_TYPE_ST_RTR MSGTYPE_STANDARD | MSGTYPE_RTR

    53

    54

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

    55

int TranslateBaudeRate(char* optarg){

    56

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

    57

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

    58

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

    59

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

    60

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

    61

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

    62

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

    63

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

    64

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

    65

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

    66

	return 0x0000;

    67

}

    68

    69

void

    70

canInit (s_BOARD *board)

    71

{

    72

	int baudrate;

    73

    74

#ifdef PCAN2_HEADER_

    75

	// if not the first handler

    76

	if(second_board == (s_BOARD *)board)

    77

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

    78

			CAN2_Init (baudrate,

    79

			  CAN_INIT_TYPE_ST extra_PCAN_init_params);

    80

#endif

    81

	if(first_board == (s_BOARD *)board)

    82

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

    83

			CAN_Init (baudrate,

    84

			  CAN_INIT_TYPE_ST extra_PCAN_init_params);

    85

}

    86

    87

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

    88

UNS8

    89

canReceive_driver (CAN_HANDLE fd0, Message * m)

    90

{

    91

	UNS8 data;

    92

	TPCANMsg peakMsg;

    93

	DWORD Res;

    94

	do{

    95

		// We read the queue looking for messages.

    96

		// 

    97

		//pthread_mutex_lock (&PeakCan_mutex);

    98

#ifdef PCAN2_HEADER_

    99

		// if not the first handler

   100

		if(second_board == (s_BOARD *)fd0)

   101

			Res = CAN2_Read (&peakMsg);

   102

		else

   103

#endif

   104

		if(first_board == (s_BOARD *)fd0)

   105

			Res = CAN_Read (&peakMsg);

   106

		else

   107

			Res = CAN_ERR_BUSOFF;

   108

		// A message was received

   109

		// We process the message(s)

   110

		// 

   111

		if (Res == CAN_ERR_OK)

   112

		{

   113

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

   114

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

   115

			{

   116

				if (peakMsg.MSGTYPE == CAN_ERR_BUSOFF)

   117

				{

   118

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

   119

					canInit((s_BOARD*) fd0);

   120

					usleep (10000);

   121

				}

   122

   123

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

   124

				//pthread_mutex_unlock (&PeakCan_mutex);

   125

				return peakMsg.MSGTYPE ==

   126

					MSGTYPE_STATUS ? peakMsg.DATA[2] : CAN_ERR_OVERRUN;

   127

			}

   128

			m->cob_id.w = peakMsg.ID;

   129

   130

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

   131

				m->rtr = 0;

   132

			else

   133

				m->rtr = 1;

   134

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

   135

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

   136

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

   137

   138

		}else{

   139

		//pthread_mutex_unlock (&PeakCan_mutex);

   140

		//if (Res != CAN_ERR_OK)

   141

		//{

   142

			if (!

   143

				(Res & CAN_ERR_QRCVEMPTY || Res & CAN_ERR_BUSLIGHT

   144

				 || Res & CAN_ERR_BUSHEAVY))

   145

			{

   146

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

   147

				return 1;

   148

			}

   149

			usleep (1000);		

   150

		}

   151

	}while(Res != CAN_ERR_OK);

   152

	return 0;

   153

}

   154

   155

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

   156

UNS8

   157

canSend_driver (CAN_HANDLE fd0, Message * m)

   158

{

   159

	UNS8 data;

   160

	TPCANMsg peakMsg;

   161

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

   162

	if (m->rtr == 0)

   163

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

   164

	else

   165

	{

   166

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

   167

	}

   168

	peakMsg.LEN = m->len;

   169

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

   170

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

   171

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

   172

   173

	do

   174

	{

   175

#ifdef PCAN2_HEADER_

   176

		// if not the first handler

   177

		if(second_board == (s_BOARD *)fd0)

   178

		{

   179

			errno = CAN2_Write (&peakMsg);

   180

		}

   181

		else 

   182

#endif

   183

		if(first_board == (s_BOARD *)fd0)

   184

			{

   185

				errno = CAN_Write (&peakMsg);

   186

			}

   187

		else 

   188

			goto fail;

   189

		if (errno)

   190

		{

   191

			if (errno == CAN_ERR_BUSOFF)

   192

			{

   193

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

   194

				canInit((s_BOARD*)fd0);

   195

				usleep (10000);

   196

			}

   197

			usleep (1000);

   198

		}

   199

	}

   200

	while (errno != CAN_ERR_OK);

   201

	return 0;

   202

fail:

   203

	return 1;

   204

}

   205

   206

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

   207

CAN_HANDLE

   208

canOpen_driver (s_BOARD * board)

   209

{

   210

  char busname[64];

   211

  char* pEnd;

   212

   213

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

   214

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

   215

  {

   216

      first_board = board;

   217

      printf ("First Board selected\n");

   218

      canInit(board);	

   219

      return (CAN_HANDLE)board;

   220

  }

   221

  #ifdef PCAN2_HEADER_

   222

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

   223

  {

   224

      second_board = board;

   225

      printf ("Second Board selected\n");

   226

      canInit(board);	

   227

      return (CAN_HANDLE)board;

   228

  }

   229

  #endif

   230

  return NULL;

   231

}

   232

   233

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

   234

int

   235

canClose_driver (CAN_HANDLE fd0)

   236

{

   237

#ifdef PCAN2_HEADER_

   238

	// if not the first handler

   239

	if(second_board == (s_BOARD *)fd0)

   240

	{

   241

		CAN2_Close ();

   242

		second_board = (s_BOARD *)NULL;

   243

	}else	

   244

#endif

   245

	if(first_board == (s_BOARD *)fd0)

   246

	{

   247

		CAN_Close ();

   248

		first_board = (s_BOARD *)NULL;

   249

	}

   250

	return 0;

   251

}