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("OnMasterMap1Update:%d\n", MasterMap1);

    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(void)

    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

		setNodeId(&TestSlave_Data, 0x02);

    98

    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

/***************************  EXIT  *****************************************/

   117

void Exit(CO_Data* d, UNS32 id)

   118

{

   119

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

   120

   121

		masterSendNMTstateChange(&TestMaster_Data, 0x02, NMT_Reset_Node);    

   122

   123

    	//Stop master

   124

		setState(&TestMaster_Data, Stopped);

   125

	}

   126

}

   127

   128

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

   129

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

   130

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

   131

int main(int argc,char **argv)

   132

{

   133

   134

  int c;

   135

  extern char *optarg;

   136

  char* LibraryPath="../../drivers/can_virtual/libcanfestival_can_virtual.so";

   137

   138

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

   139

  {

   140

    switch(c)

   141

    {

   142

      case 's' :

   143

        if (optarg[0] == 0)

   144

        {

   145

          help();

   146

          exit(1);

   147

        }

   148

        SlaveBoard.busname = optarg;

   149

        break;

   150

      case 'm' :

   151

        if (optarg[0] == 0)

   152

        {

   153

          help();

   154

          exit(1);

   155

        }

   156

        MasterBoard.busname = optarg;

   157

        break;

   158

      case 'S' :

   159

        if (optarg[0] == 0)

   160

        {

   161

          help();

   162

          exit(1);

   163

        }

   164

        SlaveBoard.baudrate = optarg;

   165

        break;

   166

      case 'M' :

   167

        if (optarg[0] == 0)

   168

        {

   169

          help();

   170

          exit(1);

   171

        }

   172

        MasterBoard.baudrate = optarg;

   173

        break;

   174

      case 'l' :

   175

        if (optarg[0] == 0)

   176

        {

   177

          help();

   178

          exit(1);

   179

        }

   180

        LibraryPath = optarg;

   181

        break;

   182

      default:

   183

        help();

   184

        exit(1);

   185

    }

   186

  }

   187

   188

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

   189

  /* install signal handler for manual break */

   190

	signal(SIGTERM, catch_signal);

   191

	signal(SIGINT, catch_signal);

   192

#endif

   193

	// Also Windows needs to initialize the Timer!

   194

	// Moving this line into the ifndef leads to a lethal crash!

   195

	TimerInit();

   196

   197

#ifndef NOT_USE_DYNAMIC_LOADING

   198

	if (LoadCanDriver(LibraryPath) == NULL)

   199

	    printf("Unable to load library: %s\n",LibraryPath);

   200

#endif		

   201

	// Open CAN devices

   202

   203

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

   204

   205

		TestSlave_Data.heartbeatError = TestSlave_heartbeatError;

   206

		TestSlave_Data.initialisation = TestSlave_initialisation;

   207

		TestSlave_Data.preOperational = TestSlave_preOperational;

   208

		TestSlave_Data.operational = TestSlave_operational;

   209

		TestSlave_Data.stopped = TestSlave_stopped;

   210

		TestSlave_Data.post_sync = TestSlave_post_sync;

   211

		TestSlave_Data.post_TPDO = TestSlave_post_TPDO;

   212

		TestSlave_Data.storeODSubIndex = TestSlave_storeODSubIndex;

   213

		TestSlave_Data.post_emcy = TestSlave_post_emcy;

   214

   215

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

   216

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

   217

			goto fail_slave;

   218

		}

   219

	}

   220

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

   221

   222

		TestMaster_Data.heartbeatError = TestMaster_heartbeatError;

   223

		TestMaster_Data.initialisation = TestMaster_initialisation;

   224

		TestMaster_Data.preOperational = TestMaster_preOperational;

   225

		TestMaster_Data.operational = TestMaster_operational;

   226

		TestMaster_Data.stopped = TestMaster_stopped;

   227

		TestMaster_Data.post_sync = TestMaster_post_sync;

   228

		TestMaster_Data.post_TPDO = TestMaster_post_TPDO;

   229

		TestMaster_Data.post_emcy = TestMaster_post_emcy;

   230

		TestMaster_Data.post_SlaveBootup=TestMaster_post_SlaveBootup;

   231

   232

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

   233

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

   234

			goto fail_master;

   235

		}

   236

	}

   237

   238

	// Start timer thread

   239

	StartTimerLoop(&InitNodes);

   240

   241

	// wait Ctrl-C

   242

	pause();

   243

   244

	// Stop timer thread

   245

	StopTimerLoop(&Exit);

   246

   247

	// Close CAN devices (and can threads)

   248

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

   249

fail_master:

   250

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

   251

fail_slave:

   252

	TimerCleanup();

   253

	return 0;

   254

}