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 "SlaveA.h"

    44

#include "SlaveB.h"

    45

#include "TestMasterSlaveLSS.h"

    46

    47

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

    48

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

    49

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

    50

    51

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

    52

void catch_signal(int sig)

    53

{

    54

  signal(SIGTERM, catch_signal);

    55

  signal(SIGINT, catch_signal);

    56

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

    57

}

    58

#endif

    59

    60

void help(void)

    61

{

    62

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

    63

  printf("*  TestMasterSlaveLSS                                        *\n");

    64

  printf("*                                                            *\n");

    65

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

    66

  printf("*  nodes in the same process. A master and 2 slaves. All     *\n");

    67

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

    68

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

    69

  printf("*  at 0 ms for slave node-id 0x02 and 0x03 by concise DCF.   *\n");                                  

    70

  printf("*                                                            *\n");

    71

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

    72

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

    73

  printf("*                                                            *\n");

    74

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

    75

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

    76

  printf("*                                                            *\n");

    77

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

    78

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

    79

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

    80

  printf("*                                                            *\n");

    81

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

    82

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

    83

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

    84

  printf("*                                                            *\n");

    85

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

    86

  printf("*     -m : bus name [\"2\"]                                  *\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_A *******************************/

    96

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

    97

		/* Set an invalid nodeID */

    98

		setNodeId(&TestSlaveA_Data, 0xFF);

    99

   100

		/* init */

   101

		setState(&TestSlaveA_Data, Initialisation);

   102

	}

   103

   104

	/****************************** INITIALISATION SLAVE_B *******************************/

   105

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

   106

   107

		/* Set an invalid nodeID */

   108

		setNodeId(&TestSlaveB_Data, 0xFF);

   109

   110

		/* init */

   111

		setState(&TestSlaveB_Data, Initialisation);

   112

	}

   113

   114

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

   115

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

   116

   117

		/* Defining the node Id */

   118

		setNodeId(&TestMaster_Data, 0x01);

   119

   120

		/* init */

   121

		setState(&TestMaster_Data, Initialisation);		

   122

	}

   123

}

   124

   125

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

   126

void Exit(CO_Data* d, UNS32 id)

   127

{

   128

	eprintf("Finishing.\n");

   129

	masterSendNMTstateChange (&TestMaster_Data, 0x00, NMT_Stop_Node);

   130

   131

	eprintf("reset\n");

   132

   133

	// Stop master

   134

	setState(&TestMaster_Data, Stopped);

   135

   136

}

   137

   138

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

   139

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

   140

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

   141

int main(int argc,char **argv)

   142

{

   143

   144

  int c;

   145

  extern char *optarg;

   146

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

   147

   148

  while ((c = getopt(argc, argv, "-m:a:b:M:A:B:l:")) != EOF)

   149

  {

   150

    switch(c)

   151

    {

   152

      case 'a' :

   153

        if (optarg[0] == 0)

   154

        {

   155

          help();

   156

          exit(1);

   157

        }

   158

        SlaveBoardA.busname = optarg;

   159

        break;

   160

      case 'b' :

   161

        if (optarg[0] == 0)

   162

        {

   163

          help();

   164

          exit(1);

   165

        }

   166

        SlaveBoardB.busname = optarg;

   167

        break;

   168

      case 'm' :

   169

        if (optarg[0] == 0)

   170

        {

   171

          help();

   172

          exit(1);

   173

        }

   174

        MasterBoard.busname = optarg;

   175

        break;

   176

      case 'A' :

   177

        if (optarg[0] == 0)

   178

        {

   179

          help();

   180

          exit(1);

   181

        }

   182

        SlaveBoardA.baudrate = optarg;

   183

        break;

   184

      case 'B' :

   185

        if (optarg[0] == 0)

   186

        {

   187

          help();

   188

          exit(1);

   189

        }

   190

        SlaveBoardB.baudrate = optarg;

   191

        break;

   192

      case 'M' :

   193

        if (optarg[0] == 0)

   194

        {

   195

          help();

   196

          exit(1);

   197

        }

   198

        MasterBoard.baudrate = optarg;

   199

        break;

   200

      case 'l' :

   201

        if (optarg[0] == 0)

   202

        {

   203

          help();

   204

          exit(1);

   205

        }

   206

        LibraryPath = optarg;

   207

        break;

   208

      default:

   209

        help();

   210

        exit(1);

   211

    }

   212

  }

   213

   214

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

   215

  /* install signal handler for manual break */

   216

	signal(SIGTERM, catch_signal);

   217

	signal(SIGINT, catch_signal);

   218

	TimerInit();

   219

#endif

   220

   221

#ifndef NOT_USE_DYNAMIC_LOADING

   222

	if (LoadCanDriver(LibraryPath) == NULL)

   223

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

   224

#endif		

   225

	// Open CAN devices

   226

   227

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

   228

   229

		TestSlaveA_Data.heartbeatError = TestSlaveA_heartbeatError;

   230

		TestSlaveA_Data.initialisation = TestSlaveA_initialisation;

   231

		TestSlaveA_Data.preOperational = TestSlaveA_preOperational;

   232

		TestSlaveA_Data.operational = TestSlaveA_operational;

   233

		TestSlaveA_Data.stopped = TestSlaveA_stopped;

   234

		TestSlaveA_Data.post_sync = TestSlaveA_post_sync;

   235

		TestSlaveA_Data.post_TPDO = TestSlaveA_post_TPDO;

   236

		TestSlaveA_Data.storeODSubIndex = TestSlaveA_storeODSubIndex;

   237

		TestSlaveA_Data.post_emcy = TestSlaveA_post_emcy;

   238

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

   239

		TestSlaveA_Data.lss_StoreConfiguration = TestSlaveA_StoreConfiguration;

   240

   241

		if(!canOpen(&SlaveBoardA,&TestSlaveA_Data)){

   242

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

   243

			goto fail_slaveA;

   244

		}

   245

	}

   246

   247

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

   248

   249

		TestSlaveB_Data.heartbeatError = TestSlaveB_heartbeatError;

   250

		TestSlaveB_Data.initialisation = TestSlaveB_initialisation;

   251

		TestSlaveB_Data.preOperational = TestSlaveB_preOperational;

   252

		TestSlaveB_Data.operational = TestSlaveB_operational;

   253

		TestSlaveB_Data.stopped = TestSlaveB_stopped;

   254

		TestSlaveB_Data.post_sync = TestSlaveB_post_sync;

   255

		TestSlaveB_Data.post_TPDO = TestSlaveB_post_TPDO;

   256

		TestSlaveB_Data.storeODSubIndex = TestSlaveB_storeODSubIndex;

   257

		TestSlaveB_Data.post_emcy = TestSlaveB_post_emcy;

   258

		TestSlaveB_Data.lss_StoreConfiguration = TestSlaveB_StoreConfiguration;

   259

   260

		if(!canOpen(&SlaveBoardB,&TestSlaveB_Data)){

   261

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

   262

			goto fail_slaveB;

   263

		}

   264

	}

   265

   266

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

   267

   268

		TestMaster_Data.heartbeatError = TestMaster_heartbeatError;

   269

		TestMaster_Data.initialisation = TestMaster_initialisation;

   270

		TestMaster_Data.preOperational = TestMaster_preOperational;

   271

		TestMaster_Data.operational = TestMaster_operational;

   272

		TestMaster_Data.stopped = TestMaster_stopped;

   273

		TestMaster_Data.post_sync = TestMaster_post_sync;

   274

		TestMaster_Data.post_TPDO = TestMaster_post_TPDO;

   275

		TestMaster_Data.post_emcy = TestMaster_post_emcy;

   276

		TestMaster_Data.post_SlaveBootup=TestMaster_post_SlaveBootup;

   277

   278

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

   279

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

   280

			goto fail_master;

   281

		}

   282

	}

   283

   284

	// Start timer thread

   285

	StartTimerLoop(&InitNodes);

   286

   287

	// wait Ctrl-C

   288

   289

	pause();

   290

   291

	// Stop timer thread

   292

	StopTimerLoop(&Exit);

   293

   294

	// Close CAN devices (and can threads)

   295

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

   296

fail_master:

   297

	if(strcmp(SlaveBoardB.baudrate, "none")) canClose(&TestSlaveB_Data);

   298

fail_slaveB:

   299

	if(strcmp(SlaveBoardA.baudrate, "none")) canClose(&TestSlaveA_Data);

   300

fail_slaveA:

   301

	TimerCleanup();

   302

	return 0;

   303

}