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

    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

    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

    94

	DWORD Res;

    95

    96

	do{

    97

		// We read the queue looking for messages.

    98

		// 

    99

		//pthread_mutex_lock (&PeakCan_mutex);

   100

#ifdef PCAN2_HEADER_

   101

		// if not the first handler

   102

		if(second_board == (s_BOARD *)fd0)

   103

			Res = CAN2_Read (&peakMsg);

   104

		else

   105

#endif

   106

		if(first_board == (s_BOARD *)fd0)

   107

			Res = CAN_Read (&peakMsg);

   108

		else

   109

			Res = CAN_ERR_BUSOFF;

   110

   111

		// A message was received

   112

		// We process the message(s)

   113

		// 

   114

		if (Res == CAN_ERR_OK)

   115

		{

   116

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

   117

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

   118

			{

   119

				if (peakMsg.MSGTYPE == CAN_ERR_BUSOFF)

   120

				{

   121

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

   122

					canInit((s_BOARD*) fd0);

   123

					usleep (10000);

   124

				}

   125

   126

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

   127

				//pthread_mutex_unlock (&PeakCan_mutex);

   128

				return peakMsg.MSGTYPE ==

   129

					MSGTYPE_STATUS ? peakMsg.DATA[2] : CAN_ERR_OVERRUN;

   130

			}

   131

			m->cob_id.w = peakMsg.ID;

   132

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

   133

				m->rtr = 0;

   134

			else

   135

				m->rtr = 1;

   136

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

   137

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

   138

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

   139

   140

		}else{

   141

		//pthread_mutex_unlock (&PeakCan_mutex);

   142

		//if (Res != CAN_ERR_OK)

   143

		//{

   144

			if (!

   145

				(Res & CAN_ERR_QRCVEMPTY || Res & CAN_ERR_BUSLIGHT

   146

				 || Res & CAN_ERR_BUSHEAVY))

   147

			{

   148

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

   149

				return 1;

   150

			}

   151

			usleep (1000);		

   152

		}

   153

	}while(Res != CAN_ERR_OK);

   154

	return 0;

   155

}

   156

   157

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

   158

UNS8

   159

canSend_driver (CAN_HANDLE fd0, Message * m)

   160

{

   161

	UNS8 data;

   162

	TPCANMsg peakMsg;

   163

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

   164

	if (m->rtr == 0)

   165

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

   166

	else

   167

	{

   168

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

   169

	}

   170

	peakMsg.LEN = m->len;

   171

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

   172

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

   173

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

   174

	do

   175

	{

   176

#ifdef PCAN2_HEADER_

   177

		// if not the first handler

   178

		if(second_board == (s_BOARD *)fd0)

   179

			errno = CAN2_Write (&peakMsg);

   180

		else 

   181

#endif

   182

		if(first_board == (s_BOARD *)fd0)

   183

			errno = CAN_Write (&peakMsg);

   184

		else 

   185

			goto fail;

   186

		if (errno)

   187

		{

   188

			if (errno == CAN_ERR_BUSOFF)

   189

			{

   190

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

   191

				canInit((s_BOARD*)fd0);

   192

				usleep (10000);

   193

			}

   194

			usleep (1000);

   195

		}

   196

	}

   197

	while (errno != CAN_ERR_OK);

   198

	return 0;

   199

fail:

   200

	return 1;

   201

}

   202

   203

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

   204

CAN_HANDLE

   205

canOpen_driver (s_BOARD * board)

   206

{

   207

#ifdef PCAN2_HEADER_

   208

	if(first_board != NULL && second_board != NULL)

   209

#else

   210

	if(first_board != NULL)

   211

#endif

   212

	{

   213

		fprintf (stderr, "Open failed.\n");

   214

		fprintf (stderr,

   215

				 "can_peak_win32.c: no more can port available with this pcan library\n");

   216

		fprintf (stderr,

   217

				 "can_peak_win32.c: please link another executable with another pcan lib\n");

   218

		return NULL;

   219

	}

   220

   221

#ifdef PCAN2_HEADER_

   222

	if(first_board == NULL)

   223

		first_board = board;

   224

	else

   225

		second_board = board; 

   226

#else

   227

	first_board = board;

   228

#endif

   229

   230

	canInit(board);

   231

   232

	return (CAN_HANDLE)board;

   233

}

   234

   235

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

   236

int

   237

canClose_driver (CAN_HANDLE fd0)

   238

{

   239

#ifdef PCAN2_HEADER_

   240

	// if not the first handler

   241

	if(second_board == (s_BOARD *)fd0)

   242

	{

   243

		CAN2_Close ();

   244

		second_board = (s_BOARD *)NULL;

   245

	}else	

   246

#endif

   247

	if(first_board == (s_BOARD *)fd0)

   248

	{

   249

		CAN_Close ();

   250

		first_board = (s_BOARD *)NULL;

   251

	}

   252

	return 0;

   253

}