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

#include <windows.h>

    25

#include "getopt.h"

    26

void pause(void)

    27

{

    28

	system("PAUSE");

    29

}

    30

#else

    31

#include <stdio.h>

    32

#include <string.h>

    33

//#include <sys/time.h>

    34

//#include <unistd.h>

    35

#include <stdlib.h>

    36

#include <signal.h>

    37

#endif

    38

    39

#include "canfestival.h"

    40

//#include <can_driver.h>

    41

//#include <timers_driver.h>

    42

    43

#include "Master.h"

    44

#include "Slave.h"

    45

#include "TestMasterSlave.h"

    46

    47

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

    48

{

    49

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

    50

	return 0;

    51

}

    52

    53

s_BOARD SlaveBoard = {"0", "500K"};

    54

s_BOARD MasterBoard = {"1", "500K"};

    55

    56

#if !defined(WIN32) || defined(__CYGWIN__)

    57

void catch_signal(int sig)

    58

{

    59

  signal(SIGTERM, catch_signal);

    60

  signal(SIGINT, catch_signal);

    61

  eprintf("Got Signal %d\n",sig);

    62

}

    63

#endif

    64

    65

void help()

    66

{

    67

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

    68

  printf("*  TestMasterSlave                                           *\n");

    69

  printf("*                                                            *\n");

    70

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

    71

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

    72

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

    73

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

    74

  printf("*                                                            *\n");

    75

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

    76

  printf("*   ./TestMasterSlave  [OPTIONS]                             *\n");

    77

  printf("*                                                            *\n");

    78

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

    79

  printf("*     -l : Can library [\"libcanfestival_can_virtual.so\"]     *\n");

    80

  printf("*                                                            *\n");

    81

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

    82

  printf("*     -s : bus name [\"0\"]                                    *\n");

    83

  printf("*     -S : 1M,500K,250K,125K,100K,50K,20K,10K,none(disable)  *\n");

    84

  printf("*                                                            *\n");

    85

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

    86

  printf("*     -m : bus name [\"1\"]                                    *\n");

    87

  printf("*     -M : 1M,500K,250K,125K,100K,50K,20K,10K,none(disable)  *\n");

    88

  printf("*                                                            *\n");

    89

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

    90

}

    91

    92

/***************************  INIT  *****************************************/

    93

void InitNodes(CO_Data* d, UNS32 id)

    94

{

    95

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

    96

	if(SlaveBoard.baudrate) {

    97

		/* Defining the node Id */

    98

		setNodeId(&TestSlave_Data, 0x02);

    99

		/* init */

   100

		setState(&TestSlave_Data, Initialisation);

   101

	}

   102

   103

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

   104

	if(MasterBoard.baudrate){

   105

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

   106

   107

		/* Defining the node Id */

   108

		setNodeId(&TestMaster_Data, 0x01);

   109

   110

		/* init */

   111

		setState(&TestMaster_Data, Initialisation);

   112

   113

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

   114

		/* Put the master in operational mode */

   115

		setState(&TestMaster_Data, Operational);

   116

   117

		/* Ask slave node to go in operational mode */

   118

		masterSendNMTstateChange (&TestMaster_Data, 0x02, NMT_Start_Node);

   119

	}

   120

}

   121

   122

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

   123

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

   124

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

   125

int main(int argc,char **argv)

   126

{

   127

   128

  char c;

   129

  extern char *optarg;

   130

  char* LibraryPath="libcanfestival_can_virtual.so";

   131

   132

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

   133

  {

   134

    switch(c)

   135

    {

   136

      case 's' :

   137

        if (optarg[0] == 0)

   138

        {

   139

          help();

   140

          exit(1);

   141

        }

   142

        SlaveBoard.busname = optarg;

   143

        break;

   144

      case 'm' :

   145

        if (optarg[0] == 0)

   146

        {

   147

          help();

   148

          exit(1);

   149

        }

   150

        MasterBoard.busname = optarg;

   151

        break;

   152

      case 'S' :

   153

        if (optarg[0] == 0)

   154

        {

   155

          help();

   156

          exit(1);

   157

        }

   158

        SlaveBoard.baudrate = optarg;

   159

        break;

   160

      case 'M' :

   161

        if (optarg[0] == 0)

   162

        {

   163

          help();

   164

          exit(1);

   165

        }

   166

        MasterBoard.baudrate = optarg;

   167

        break;

   168

      case 'l' :

   169

        if (optarg[0] == 0)

   170

        {

   171

          help();

   172

          exit(1);

   173

        }

   174

        LibraryPath = optarg;

   175

        break;

   176

      default:

   177

        help();

   178

        exit(1);

   179

    }

   180

  }

   181

   182

#if !defined(WIN32) || defined(__CYGWIN__)

   183

  /* install signal handler for manual break */

   184

	signal(SIGTERM, catch_signal);

   185

	signal(SIGINT, catch_signal);

   186

#endif

   187

   188

#ifndef NOT_USE_DYNAMIC_LOADING

   189

	LoadCanDriver(LibraryPath);

   190

#endif		

   191

	// Open CAN devices

   192

	if(SlaveBoard.baudrate){

   193

   194

		TestSlave_Data.heartbeatError = TestSlave_heartbeatError;

   195

		TestSlave_Data.SDOtimeoutError = TestSlave_SDOtimeoutError;

   196

		TestSlave_Data.initialisation = TestSlave_initialisation;

   197

		TestSlave_Data.preOperational = TestSlave_preOperational;

   198

		TestSlave_Data.operational = TestSlave_operational;

   199

		TestSlave_Data.stopped = TestSlave_stopped;

   200

		TestSlave_Data.post_sync = TestSlave_post_sync;

   201

		TestSlave_Data.post_TPDO = TestSlave_post_TPDO;

   202

   203

		if(!canOpen(&SlaveBoard,&TestSlave_Data)){

   204

			eprintf("Cannot open Slave Board (%s,%s)\n",SlaveBoard.busname, SlaveBoard.baudrate);

   205

			goto fail_slave;

   206

		}

   207

	}

   208

   209

	if(MasterBoard.baudrate){

   210

   211

		TestMaster_Data.heartbeatError = TestMaster_heartbeatError;

   212

		TestMaster_Data.SDOtimeoutError = TestMaster_SDOtimeoutError;

   213

		TestMaster_Data.initialisation = TestMaster_initialisation;

   214

		TestMaster_Data.preOperational = TestMaster_preOperational;

   215

		TestMaster_Data.operational = TestMaster_operational;

   216

		TestMaster_Data.stopped = TestMaster_stopped;

   217

		TestMaster_Data.post_sync = TestMaster_post_sync;

   218

		TestMaster_Data.post_TPDO = TestMaster_post_TPDO;

   219

   220

		if(!canOpen(&MasterBoard,&TestMaster_Data)){

   221

			eprintf("Cannot open Master Board (%s,%s)\n",SlaveBoard.busname, SlaveBoard.baudrate);

   222

			goto fail_master;

   223

		}

   224

	}

   225

   226

	// Start timer thread

   227

	StartTimerLoop(&InitNodes);

   228

   229

	// wait Ctrl-C

   230

	pause();

   231

	eprintf("Finishing.\n");

   232

   233

	// Stop timer thread

   234

	StopTimerLoop();

   235

   236

	// Close CAN devices (and can threads)

   237

	if(SlaveBoard.baudrate) canClose(&TestSlave_Data);

   238

fail_master:

   239

	if(MasterBoard.baudrate) canClose(&TestMaster_Data);	

   240

fail_slave:

   241

   242

   243

  return 0;

   244

}