1

/*

     2

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

     3

     4

Copyright (C): Jorge BERZOSA

     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

/*

    24

* can4linux driver

    25

*/

    26

    27

#include <stdio.h>

    28

#include <string.h>

    29

#include <errno.h>

    30

#include <fcntl.h>

    31

    32

#include "can4linux.h" 

    33

#include "can_driver.h"

    34

    35

struct timeval init_time,current_time;

    36

    37

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

    38

UNS8 canReceive_driver(CAN_HANDLE fd0, Message *m)

    39

{

    40

  int res,i;

    41

  canmsg_t canmsg;

    42

  long int time_period;

    43

    44

	canmsg.flags = 0; 

    45

	do{

    46

   		res = read(fd0,&canmsg,1);

    47

   		if((res<0)&&(errno == -EAGAIN)) res = 0;

    48

	}while(res==0);

    49

    50

	if(res !=1) // No new message

    51

   	return 1;

    52

    53

	if(canmsg.flags&MSG_EXT){

    54

   		/* There is no mark for extended messages in CanFestival */;

    55

	}

    56

    57

	m->cob_id = canmsg.id;

    58

	m->len = canmsg.length;

    59

	if(canmsg.flags&MSG_RTR){

    60

 		m->rtr = 1;

    61

	}else{

    62

 		m->rtr = 0;

    63

 		memcpy(m->data,canmsg.data,8);

    64

	}

    65

    66

    67

 	/*gettimeofday(&current_time,NULL);

    68

 	time_period=(current_time.tv_sec - init_time.tv_sec)* 1000000 + current_time.tv_usec - init_time.tv_usec;

    69

 	printf("%3ld.%3ld.%3ld - Receive ID: %lx ->",time_period/1000000,(time_period%1000000)/1000,time_period%1000,m->cob_id);

    70

 	printf("Receive ID: %lx ->",m->cob_id);

    71

 	for(i=0; i<canmsg.length;i++)printf("%x, ", m->data[i]);

    72

 	printf("\n");*/

    73

    74

  return 0;

    75

}

    76

    77

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

    78

UNS8 canSend_driver(CAN_HANDLE fd0, Message *m)

    79

{

    80

  int res;

    81

  canmsg_t canmsg;

    82

    83

  canmsg.flags = 0;

    84

  canmsg.id = m->cob_id;

    85

  canmsg.length = m->len;

    86

  if(m->rtr){

    87

    canmsg.flags |= MSG_RTR;

    88

  }else{

    89

    memcpy(canmsg.data,m->data,8);

    90

  }

    91

    92

 /*printf("Send ID: %lx ->",canmsg.id); 

    93

 for(i=0; i<canmsg.length;i++)printf("%x, ", canmsg.data[i]);

    94

 printf("\n");*/

    95

    96

  if(canmsg.id >= 0x800){

    97

    canmsg.flags |= MSG_EXT;

    98

  }

    99

   100

  res = write(fd0,&canmsg,1);

   101

  if(res!=1)

   102

    return 1;

   103

   104

  return 0;

   105

}

   106

   107

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

   108

int	set_bitrate( CAN_HANDLE fd, int baud)

   109

{

   110

    Config_par_t  cfg;	

   111

    volatile Command_par_t cmd;

   112

   113

    cmd.cmd = CMD_STOP;

   114

    ioctl(fd, COMMAND, &cmd);

   115

   116

    cfg.target = CONF_TIMING; 

   117

    cfg.val1   = baud;

   118

    ioctl(fd, CONFIG, &cfg);

   119

   120

    cmd.cmd = CMD_START;

   121

    ioctl(fd, COMMAND, &cmd);

   122

    return 0;

   123

}

   124

   125

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

   126

int TranslateBaudeRate(char* optarg){

   127

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

   128

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

   129

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

   130

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

   131

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

   132

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

   133

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

   134

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

   135

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

   136

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

   137

	return 0x0000;

   138

}

   139

   140

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

   141

static const char lnx_can_dev_prefix[] = "/dev/can";

   142

   143

CAN_HANDLE canOpen_driver(s_BOARD *board)

   144

{

   145

  int name_len = strlen(board->busname);

   146

  int prefix_len = strlen(lnx_can_dev_prefix);

   147

  char dev_name[prefix_len+name_len+1];

   148

  int o_flags = 0;

   149

  int baud = TranslateBaudeRate(board->baudrate);

   150

  int fd0;

   151

   152

   153

  /*o_flags = O_NONBLOCK;*/

   154

   155

  memcpy(dev_name,lnx_can_dev_prefix,prefix_len);

   156

  memcpy(dev_name+prefix_len,board->busname,name_len);

   157

  dev_name[prefix_len+name_len] = 0;

   158

   159

  fd0 = open(dev_name, O_RDWR|o_flags);

   160

  if(fd0 <= 0){

   161

    fprintf(stderr,"!!! %s is unknown. See can4linux.c\n", dev_name);

   162

    goto error_ret;

   163

  }

   164

   165

  set_bitrate((CAN_HANDLE)fd0, baud);

   166

   167

  printf("CAN device dev/can%s opened. Baudrate=>%s\n",board->busname, board->baudrate);

   168

   169

  return (CAN_HANDLE)fd0;

   170

   171

 error_ret:

   172

  return NULL;

   173

}

   174

   175

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

   176

int canClose_driver(CAN_HANDLE fd0)

   177

{

   178

  if((int)fd0<=0)

   179

    return -1;

   180

  close(fd0);

   181

  return 0;

   182

}