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 <unistd.h>

    34

#include <stdlib.h>

    35

#include <signal.h>

    36

#endif

    37

    38

#include "canfestival.h"

    39

//#include <can_driver.h>

    40

//#include <timers_driver.h>

    41

    42

#include "Master.h"

    43

#include "Slave.h"

    44

#include "TestMasterSlave.h"

    45

    46

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

    47

{

    48

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

    49

	return 0;

    50

}

    51

    52

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

    53

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

    54

    55

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

    56

void catch_signal(int sig)

    57

{

    58

  signal(SIGTERM, catch_signal);

    59

  signal(SIGINT, catch_signal);

    60

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

    61

}

    62

#endif

    63

    64

void help()

    65

{

    66

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

    67

  printf("*  TestMasterSlave                                           *\n");

    68

  printf("*                                                            *\n");

    69

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

    70

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

    71

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

    72

  printf("*  SDO and PDO. Master configure heartbeat producer time     *\n");

    73

  printf("*  at 1000 ms for slave node-id 0x02 by concise DCF.         *\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(strcmp(SlaveBoard.baudrate, "none")) {

    97

		/* Defining the node Id */

    98

		setNodeId(&TestSlave_Data, 0x02);

    99

		/* init */

   100

		setState(&TestSlave_Data, Initialisation);

   101

	}

   102

   103

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

   104

	if(strcmp(MasterBoard.baudrate, "none")){

   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

	}

   114

}

   115

   116

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

   117

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

   118

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

   119

int main(int argc,char **argv)

   120

{

   121

   123

  extern char *optarg;

   124

  char* LibraryPath="libcanfestival_can_virtual.so";

   125

   126

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

   127

  {

   128

    switch(c)

   129

    {

   130

      case 's' :

   131

        if (optarg[0] == 0)

   132

        {

   133

          help();

   134

          exit(1);

   135

        }

   136

        SlaveBoard.busname = optarg;

   137

        break;

   138

      case 'm' :

   139

        if (optarg[0] == 0)

   140

        {

   141

          help();

   142

          exit(1);

   143

        }

   144

        MasterBoard.busname = optarg;

   145

        break;

   146

      case 'S' :

   147

        if (optarg[0] == 0)

   148

        {

   149

          help();

   150

          exit(1);

   151

        }

   152

        SlaveBoard.baudrate = optarg;

   153

        break;

   154

      case 'M' :

   155

        if (optarg[0] == 0)

   156

        {

   157

          help();

   158

          exit(1);

   159

        }

   160

        MasterBoard.baudrate = optarg;

   161

        break;

   162

      case 'l' :

   163

        if (optarg[0] == 0)

   164

        {

   165

          help();

   166

          exit(1);

   167

        }

   168

        LibraryPath = optarg;

   169

        break;

   170

      default:

   171

        help();

   172

        exit(1);

   173

    }

   174

  }

   175

   176

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

   177

  /* install signal handler for manual break */

   178

	signal(SIGTERM, catch_signal);

   179

	signal(SIGINT, catch_signal);

   180

#endif

   181

   182

#ifndef NOT_USE_DYNAMIC_LOADING

   183

	LoadCanDriver(LibraryPath);

   184

#endif		

   185

	// Open CAN devices

   186

   187

	if(strcmp(SlaveBoard.baudrate, "none")){

   188

   189

		TestSlave_Data.heartbeatError = TestSlave_heartbeatError;

   190

		TestSlave_Data.initialisation = TestSlave_initialisation;

   191

		TestSlave_Data.preOperational = TestSlave_preOperational;

   192

		TestSlave_Data.operational = TestSlave_operational;

   193

		TestSlave_Data.stopped = TestSlave_stopped;

   194

		TestSlave_Data.post_sync = TestSlave_post_sync;

   195

		TestSlave_Data.post_TPDO = TestSlave_post_TPDO;

   196

		TestSlave_Data.storeODSubIndex = TestSlave_storeODSubIndex;		

   197

   198

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

   199

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

   200

			goto fail_slave;

   201

		}

   202

	}

   203

	if(strcmp(MasterBoard.baudrate, "none")){

   204

   205

		TestMaster_Data.heartbeatError = TestMaster_heartbeatError;

   206

		TestMaster_Data.initialisation = TestMaster_initialisation;

   207

		TestMaster_Data.preOperational = TestMaster_preOperational;

   208

		TestMaster_Data.operational = TestMaster_operational;

   209

		TestMaster_Data.stopped = TestMaster_stopped;

   210

		TestMaster_Data.post_sync = TestMaster_post_sync;

   211

		TestMaster_Data.post_TPDO = TestMaster_post_TPDO;

   212

   213

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

   214

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

   215

			goto fail_master;

   216

		}

   217

	}

   218

	sleep(2);

   219

	// Start timer thread

   220

	StartTimerLoop(&InitNodes);

   221

   222

	// wait Ctrl-C

   223

   224

	pause();

   225

	eprintf("Finishing.\n");

   226

   227

	masterSendNMTstateChange (&TestMaster_Data, 0x02, NMT_Reset_Node);

   228

	eprintf("reset\n");

   229

	// Stop master

   230

	setState(&TestMaster_Data, Stopped);

   231

   232

	// Stop timer thread

   233

	StopTimerLoop();

   234

   235

	// Close CAN devices (and can threads)

   236

	if(strcmp(SlaveBoard.baudrate, "none")) canClose(&TestSlave_Data);

   237

fail_master:

   238

	if(strcmp(MasterBoard.baudrate, "none")) canClose(&TestMaster_Data);	

   239

fail_slave:

   240

	return 0;

   241

}