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

   122

  int c;

   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

		TestSlave_Data.post_emcy = TestSlave_post_emcy;

   198

   199

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

   200

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

   201

			goto fail_slave;

   202

		}

   203

	}

   204

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

   205

   206

		TestMaster_Data.heartbeatError = TestMaster_heartbeatError;

   207

		TestMaster_Data.initialisation = TestMaster_initialisation;

   208

		TestMaster_Data.preOperational = TestMaster_preOperational;

   209

		TestMaster_Data.operational = TestMaster_operational;

   210

		TestMaster_Data.stopped = TestMaster_stopped;

   211

		TestMaster_Data.post_sync = TestMaster_post_sync;

   212

		TestMaster_Data.post_TPDO = TestMaster_post_TPDO;

   213

		TestMaster_Data.post_emcy = TestMaster_post_emcy;

   214

   215

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

   216

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

   217

			goto fail_master;

   218

		}

   219

	}

   220

   221

	// Start timer thread

   222

	StartTimerLoop(&InitNodes);

   223

   224

	// wait Ctrl-C

   225

   226

	pause();

   227

   228

	eprintf("Finishing.\n");

   229

    EnterMutex();

   230

	masterSendNMTstateChange (&TestMaster_Data, 0x02, NMT_Reset_Node);

   231

    LeaveMutex();

   232

   233

	eprintf("reset\n");

   234

	// Stop master

   235

    EnterMutex();

   236

	setState(&TestMaster_Data, Stopped);

   237

    LeaveMutex();

   238

   239

	// Stop timer thread

   240

	StopTimerLoop();

   241

   242

	// Close CAN devices (and can threads)

   243

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

   244

fail_master:

   245

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

   246

fail_slave:

   247

	return 0;

   248

}