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

    98

#ifdef CO_ENABLE_LSS

    99

		/* Set an invalid nodeID */

   100

		setNodeId(&TestSlave_Data, 0xFF);

   101

#else

   102

		setNodeId(&TestSlave_Data, 0x02);

   103

#endif

   104

   105

		/* init */

   106

		setState(&TestSlave_Data, Initialisation);

   107

	}

   108

   109

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

   110

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

   111

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

   112

   113

		/* Defining the node Id */

   114

		setNodeId(&TestMaster_Data, 0x01);

   115

   116

		/* init */

   117

		setState(&TestMaster_Data, Initialisation);

   118

   119

	}

   120

}

   121

   122

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

   123

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

   124

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

   125

int main(int argc,char **argv)

   126

{

   127

   128

  int c;

   129

  extern char *optarg;

   130

  char* LibraryPath="../../drivers/can_virtual/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

	if (LoadCanDriver(LibraryPath) == NULL)

   190

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

   191

#endif		

   192

	// Open CAN devices

   193

   194

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

   195

   196

		TestSlave_Data.heartbeatError = TestSlave_heartbeatError;

   197

		TestSlave_Data.initialisation = TestSlave_initialisation;

   198

		TestSlave_Data.preOperational = TestSlave_preOperational;

   199

		TestSlave_Data.operational = TestSlave_operational;

   200

		TestSlave_Data.stopped = TestSlave_stopped;

   201

		TestSlave_Data.post_sync = TestSlave_post_sync;

   202

		TestSlave_Data.post_TPDO = TestSlave_post_TPDO;

   203

		TestSlave_Data.storeODSubIndex = TestSlave_storeODSubIndex;

   204

		TestSlave_Data.post_emcy = TestSlave_post_emcy;

   205

#ifdef CO_ENABLE_LSS

   206

		/* in this example the slave doesn't support Store configuration*/

   207

		//TestSlave_Data.lss_StoreConfiguration = TestSlave_StoreConfiguration;

   208

		TestSlave_Data.lss_ChangeBaudRate=TestSlave_ChangeBaudRate;

   209

#endif

   210

   211

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

   212

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

   213

			goto fail_slave;

   214

		}

   215

	}

   216

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

   217

   218

		TestMaster_Data.heartbeatError = TestMaster_heartbeatError;

   219

		TestMaster_Data.initialisation = TestMaster_initialisation;

   220

		TestMaster_Data.preOperational = TestMaster_preOperational;

   221

		TestMaster_Data.operational = TestMaster_operational;

   222

		TestMaster_Data.stopped = TestMaster_stopped;

   223

		TestMaster_Data.post_sync = TestMaster_post_sync;

   224

		TestMaster_Data.post_TPDO = TestMaster_post_TPDO;

   225

		TestMaster_Data.post_emcy = TestMaster_post_emcy;

   226

		TestMaster_Data.post_SlaveBootup=TestMaster_post_SlaveBootup;

   227

   228

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

   229

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

   230

			goto fail_master;

   231

		}

   232

	}

   233

   234

	// Start timer thread

   235

	StartTimerLoop(&InitNodes);

   236

   237

	// wait Ctrl-C

   238

   239

	pause();

   240

   241

	eprintf("Finishing.\n");

   242

    EnterMutex();

   243

	masterSendNMTstateChange (&TestMaster_Data, 0x02, NMT_Reset_Node);

   244

    LeaveMutex();

   245

   246

	eprintf("reset\n");

   247

	// Stop master

   248

    EnterMutex();

   249

	setState(&TestMaster_Data, Stopped);

   250

    LeaveMutex();

   251

   252

	// Stop timer thread

   253

	StopTimerLoop();

   254

   255

	// Close CAN devices (and can threads)

   256

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

   257

fail_master:

   258

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

   259

fail_slave:

   260

	return 0;

   261

}