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

    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

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

   126

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

   127

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

   128

int main(int argc,char **argv)

   129

{

   130

   131

  int c;

   132

  extern char *optarg;

   133

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

   134

   135

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

   136

  {

   137

    switch(c)

   138

    {

   139

      case 'a' :

   140

        if (optarg[0] == 0)

   141

        {

   142

          help();

   143

          exit(1);

   144

        }

   145

        SlaveBoardA.busname = optarg;

   146

        break;

   147

      case 'b' :

   148

        if (optarg[0] == 0)

   149

        {

   150

          help();

   151

          exit(1);

   152

        }

   153

        SlaveBoardB.busname = optarg;

   154

        break;

   155

      case 'm' :

   156

        if (optarg[0] == 0)

   157

        {

   158

          help();

   159

          exit(1);

   160

        }

   161

        MasterBoard.busname = optarg;

   162

        break;

   163

      case 'A' :

   164

        if (optarg[0] == 0)

   165

        {

   166

          help();

   167

          exit(1);

   168

        }

   169

        SlaveBoardA.baudrate = optarg;

   170

        break;

   171

      case 'B' :

   172

        if (optarg[0] == 0)

   173

        {

   174

          help();

   175

          exit(1);

   176

        }

   177

        SlaveBoardB.baudrate = optarg;

   178

        break;

   179

      case 'M' :

   180

        if (optarg[0] == 0)

   181

        {

   182

          help();

   183

          exit(1);

   184

        }

   185

        MasterBoard.baudrate = optarg;

   186

        break;

   187

      case 'l' :

   188

        if (optarg[0] == 0)

   189

        {

   190

          help();

   191

          exit(1);

   192

        }

   193

        LibraryPath = optarg;

   194

        break;

   195

      default:

   196

        help();

   197

        exit(1);

   198

    }

   199

  }

   200

   201

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

   202

  /* install signal handler for manual break */

   203

	signal(SIGTERM, catch_signal);

   204

	signal(SIGINT, catch_signal);

   205

#endif

   206

   207

#ifndef NOT_USE_DYNAMIC_LOADING

   208

	if (LoadCanDriver(LibraryPath) == NULL)

   209

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

   210

#endif		

   211

	// Open CAN devices

   212

   213

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

   214

   215

		TestSlaveA_Data.heartbeatError = TestSlaveA_heartbeatError;

   216

		TestSlaveA_Data.initialisation = TestSlaveA_initialisation;

   217

		TestSlaveA_Data.preOperational = TestSlaveA_preOperational;

   218

		TestSlaveA_Data.operational = TestSlaveA_operational;

   219

		TestSlaveA_Data.stopped = TestSlaveA_stopped;

   220

		TestSlaveA_Data.post_sync = TestSlaveA_post_sync;

   221

		TestSlaveA_Data.post_TPDO = TestSlaveA_post_TPDO;

   222

		TestSlaveA_Data.storeODSubIndex = TestSlaveA_storeODSubIndex;

   223

		TestSlaveA_Data.post_emcy = TestSlaveA_post_emcy;

   224

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

   225

		TestSlaveA_Data.lss_StoreConfiguration = TestSlaveA_StoreConfiguration;

   226

   227

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

   228

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

   229

			goto fail_slaveA;

   230

		}

   231

	}

   232

   233

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

   234

   235

		TestSlaveB_Data.heartbeatError = TestSlaveB_heartbeatError;

   236

		TestSlaveB_Data.initialisation = TestSlaveB_initialisation;

   237

		TestSlaveB_Data.preOperational = TestSlaveB_preOperational;

   238

		TestSlaveB_Data.operational = TestSlaveB_operational;

   239

		TestSlaveB_Data.stopped = TestSlaveB_stopped;

   240

		TestSlaveB_Data.post_sync = TestSlaveB_post_sync;

   241

		TestSlaveB_Data.post_TPDO = TestSlaveB_post_TPDO;

   242

		TestSlaveB_Data.storeODSubIndex = TestSlaveB_storeODSubIndex;

   243

		TestSlaveB_Data.post_emcy = TestSlaveB_post_emcy;

   244

		TestSlaveB_Data.lss_StoreConfiguration = TestSlaveB_StoreConfiguration;

   245

   246

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

   247

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

   248

			goto fail_slaveB;

   249

		}

   250

	}

   251

   252

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

   253

   254

		TestMaster_Data.heartbeatError = TestMaster_heartbeatError;

   255

		TestMaster_Data.initialisation = TestMaster_initialisation;

   256

		TestMaster_Data.preOperational = TestMaster_preOperational;

   257

		TestMaster_Data.operational = TestMaster_operational;

   258

		TestMaster_Data.stopped = TestMaster_stopped;

   259

		TestMaster_Data.post_sync = TestMaster_post_sync;

   260

		TestMaster_Data.post_TPDO = TestMaster_post_TPDO;

   261

		TestMaster_Data.post_emcy = TestMaster_post_emcy;

   262

		TestMaster_Data.post_SlaveBootup=TestMaster_post_SlaveBootup;

   263

   264

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

   265

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

   266

			goto fail_master;

   267

		}

   268

	}

   269

   270

	// Start timer thread

   271

	StartTimerLoop(&InitNodes);

   272

   273

	// wait Ctrl-C

   274

   275

	pause();

   276

   277

	eprintf("Finishing.\n");

   278

    EnterMutex();

   279

	masterSendNMTstateChange (&TestMaster_Data, 0x00, NMT_Stop_Node);

   280

    LeaveMutex();

   281

   282

	eprintf("reset\n");

   283

	// Stop master

   284

    EnterMutex();

   285

	setState(&TestMaster_Data, Stopped);

   286

    LeaveMutex();

   287

   288

	// Stop timer thread

   289

	StopTimerLoop();

   290

   291

	// Close CAN devices (and can threads)

   292

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

   293

fail_master:

   294

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

   295

fail_slaveB:

   296

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

   297

fail_slaveA:

   298

	return 0;

   299

}