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

/*

    24

	Virtual CAN driver.

    25

*/

    26

    27

#include <stdio.h>

    28

#include <unistd.h>

    29

    30

#include "can_driver.h"

    32

    33

#define MAX_NB_CAN_PIPES 16

    34

    35

typedef struct {

    36

  char used;

    37

  int pipe[2];

    38

} CANPipe;

    39

    40

CANPipe canpipes[MAX_NB_CAN_PIPES] = {{0,},{0,},{0,},{0,},{0,},{0,},{0,},{0,},{0,},{0,},{0,},{0,},{0,},{0,},{0,},{0,},};

    41

    42

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

    43

UNS8 canReceive_driver(CAN_HANDLE fd0, Message *m)

    44

{

    45

	if(read(((CANPipe*)fd0)->pipe[0], m, sizeof(Message)) < sizeof(Message))

    46

	{

    47

		return 1;

    48

	}

    49

	return 0;

    50

}

    51

    80

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

    81

UNS8 canSend_driver(CAN_HANDLE fd0, Message *m)

    82

{

    83

  int i;

    96

  // Send to all readers, except myself

    97

  for(i=0; i < MAX_NB_CAN_PIPES; i++)

    98

  {

    99

  	if(canpipes[i].used && &canpipes[i] != (CANPipe*)fd0)

   100

  	{

   101

		write(canpipes[i].pipe[1], m, sizeof(Message));

   102

  	}

   103

  }

   104

  return 0;

   105

}

   106

/*

   107

int TranslateBaudeRate(char* optarg){

   108

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

   109

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

   110

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

   111

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

   112

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

   113

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

   114

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

   115

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

   116

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

   117

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

   118

	return 0;

   119

}*/

   120

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

   121

CAN_HANDLE canOpen_driver(s_BOARD *board)

   122

{

   123

  int i;  

   124

  for(i=0; i < MAX_NB_CAN_PIPES; i++)

   125

  {

   126

  	if(!canpipes[i].used)

   127

	  	break;

   128

  }

   129

   130

  /* Create the pipe.  */

   131

  if (i==MAX_NB_CAN_PIPES || pipe(canpipes[i].pipe))

   132

    {

   133

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

   134

      return (CAN_HANDLE)NULL;

   135

    }

   136

   137

   canpipes[i].used = 1;

   138

   return (CAN_HANDLE) &canpipes[i];

   139

}

   140

   141

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

   142

int canClose_driver(CAN_HANDLE fd0)

   143

{

   144

  close(((CANPipe*)fd0)->pipe[0]);

   145

  close(((CANPipe*)fd0)->pipe[1]);

   146

  ((CANPipe*)fd0)->used = 0;

   147

  return 0;

   148

}

   149

   150