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

#include <stdio.h>

    24

#include <string.h>

    25

#include <sys/time.h>

    26

#include <unistd.h>

    27

#include <stdlib.h>

    28

#include <signal.h>

    29

    30

#include <applicfg.h>

    31

#include <can_driver.h>

    32

#include <timers_driver.h>

    33

    34

#include "Master.h"

    35

#include "Slave.h"

    36

#include "TestMasterSlave.h"

    37

    38

#define MyCase(fc) case fc: eprintf(#fc);break;

    39

void print_message(Message *m)

    40

{

    41

	int i;

    42

	switch(m->cob_id.w >> 7)

    43

	{

    44

		MyCase(SYNC)

    45

		MyCase(TIME_STAMP)

    46

		MyCase(PDO1tx)

    47

		MyCase(PDO1rx)

    48

		MyCase(PDO2tx)

    49

		MyCase(PDO2rx)

    50

		MyCase(PDO3tx)

    51

		MyCase(PDO3rx)

    52

		MyCase(PDO4tx)

    53

		MyCase(PDO4rx)

    54

		MyCase(SDOtx)

    55

		MyCase(SDOrx)

    56

		MyCase(NODE_GUARD)

    57

		MyCase(NMT)

    58

	}

    59

	eprintf(" rtr:%d", m->rtr);

    60

	eprintf(" len:%d", m->len);

    61

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

    62

		eprintf(" %02x", m->data[i]);

    63

	eprintf("\n");

    64

}

    65

    66

UNS32 OnMasterMap1Update(CO_Data* d, const indextable * unsused_indextable, UNS8 unsused_bSubindex)

    67

{

    68

	eprintf("OnSlaveMap1Update:%d\n", SlaveMap1);

    70

}

    71

    72

    73

    74

void InitNodes(CO_Data* d, UNS32 id)

    75

{

    76

//  TestSlave_Index2000_callbacks[0] = &OnMasterMap1Update;

    77

  RegisterSetODentryCallBack(&TestMaster_Data, 0x2000, 0, &OnMasterMap1Update);

    78

    79

  /****************************** INITIALISATION MASTER *******************************/

    80

  /* Defining the node Id */

    81

  setNodeId(&TestMaster_Data, 0x01);

    82

    83

  /* init */

    84

  setState(&TestMaster_Data, Initialisation);

    85

    86

  /****************************** INITIALISATION SLAVE *******************************/

    87

  /* Defining the node Id */

    88

  setNodeId(&TestSlave_Data, 0x02);

    89

    90

  /* init */

    91

  setState(&TestSlave_Data, Initialisation);

    92

    93

  /****************************** START *******************************/

    94

  /* Put the master in operational mode */

    95

  setState(&TestMaster_Data, Operational);

    96

    97

  masterSendNMTstateChange (&TestMaster_Data, 0x02, NMT_Start_Node);

    98

    99

}

   100

   101

CAN_HANDLE SlaveCanHandle;

   102

CAN_HANDLE MasterCanHandle;

   103

   104

// Baudrate values for Peak board :

   105

// CAN_BAUD_1M CAN_BAUD_500K CAN_BAUD_250K CAN_BAUD_125K CAN_BAUD_100K CAN_BAUD_50K

   106

// CAN_BAUD_20K CAN_BAUD_10K CAN_BAUD_5K

   107

   108

#ifdef CAN_BAUD_500K

   109

// Appli have been compiled for Peak. Baudrate is defined

   110

# define BAUDRATE CAN_BAUD_500K

   111

#else

   112

// Appli have been compiled for Generic. Baudrate not used

   113

# define BAUDRATE 0

   114

#endif

   115

   116

void catch_signal(int sig)

   117

{

   118

  signal(SIGTERM, catch_signal);

   119

  signal(SIGINT, catch_signal);

   120

  stopTimer();

   121

  eprintf("Got Sigterm - Finishing.\n");

   122

}

   123

   124

   125

void help()

   126

{

   127

  printf("**************************************************************\n");

   128

  printf("*  TestMasterSlave                                           *\n");

   129

  printf("*                                                            *\n");

   130

  printf("*  A simple example for PC. It does implement 2 CanOpen      *\n");

   131

  printf("*  nodes in the same process. A master and a slave. Both     *\n");

   132

  printf("*   communicate together, exchanging periodically NMT, SYNC, *\n");

   133

  printf("*   SDO and PDO.                                             *\n");

   134

  printf("*                                                            *\n");

   135

  printf("*   If you have chosen virtual CAN driver, just type         *\n");

   136

  printf("*   ./TestMasterSlave                                        *\n");

   137

  printf("*                                                            *\n");

   139

  printf("*                                                            *\n");

   140

  printf("*     -s : slave CAN bus [default 0, peak first PCI]         *\n");

   141

  printf("*     -m : master CAN bus [default 1, peak second PCI]       *\n");

   142

  printf("*                                                            *\n");

   143

  printf("**************************************************************\n");

   144

}

   145

   146

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

   147

/***************************  MAIN  *****************************************/

   148

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

   149

int main(int argc,char **argv)

   150

{

   151

	s_BOARD SlaveBoard = {"0", BAUDRATE, &TestSlave_Data};

   152

	s_BOARD MasterBoard = {"1", BAUDRATE, &TestMaster_Data};

   153

   154

   155

  char c;

   156

  extern char *optarg;

   157

   158

  while ((c = getopt(argc, argv, "-m:s:")) != EOF)

   159

  {

   160

    switch(c)

   161

    {

   162

      case 's' :

   163

        if (optarg[0] == 0)

   164

        {

   165

          help();

   166

          exit(1);

   167

        }

   168

        SlaveBoard.busname = optarg;

   169

        break;

   170

      case 'm' :

   171

        if (optarg[0] == 0)

   172

        {

   173

          help();

   174

          exit(1);

   175

        }

   176

        MasterBoard.busname = optarg;

   177

        break;

   178

      default:

   179

        help();

   180

        exit(1);

   181

    }

   182

  }

   183

   184

	/* install signal handler for manual break */

   185

	signal(SIGTERM, catch_signal);

   186

	signal(SIGINT, catch_signal);

   187

   188

	// Open CAN devices

   189

	SlaveCanHandle = canOpen(&SlaveBoard);

   190

	MasterCanHandle = canOpen(&MasterBoard);	

   191

   192

	// Will call InitNodes, and wait and handle next timer events.

   193

	TimerLoop(&InitNodes);

   194

   195

	// Close CAN devices

   196

	canClose(SlaveCanHandle);

   197

	canClose(MasterCanHandle);	

   198

   199

   200

  return 0;

   201

}