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

		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

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

   117

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

   118

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

   119

int main(int argc,char **argv)

   120

{

   121

   122

  int c;

   123

  extern char *optarg;

   124

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

	if (LoadCanDriver(LibraryPath) == NULL)

   184

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

   185

#endif		

   186

	// Open CAN devices

   187

   188

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

   189

   190

		TestSlave_Data.heartbeatError = TestSlave_heartbeatError;

   191

		TestSlave_Data.initialisation = TestSlave_initialisation;

   192

		TestSlave_Data.preOperational = TestSlave_preOperational;

   193

		TestSlave_Data.operational = TestSlave_operational;

   194

		TestSlave_Data.stopped = TestSlave_stopped;

   195

		TestSlave_Data.post_sync = TestSlave_post_sync;

   196

		TestSlave_Data.post_TPDO = TestSlave_post_TPDO;

   197

		TestSlave_Data.storeODSubIndex = TestSlave_storeODSubIndex;

   198

		TestSlave_Data.post_emcy = TestSlave_post_emcy;

   199

   200

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

   201

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

   202

			goto fail_slave;

   203

		}

   204

	}

   205

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

   206

   207

		TestMaster_Data.heartbeatError = TestMaster_heartbeatError;

   208

		TestMaster_Data.initialisation = TestMaster_initialisation;

   209

		TestMaster_Data.preOperational = TestMaster_preOperational;

   210

		TestMaster_Data.operational = TestMaster_operational;

   211

		TestMaster_Data.stopped = TestMaster_stopped;

   212

		TestMaster_Data.post_sync = TestMaster_post_sync;

   213

		TestMaster_Data.post_TPDO = TestMaster_post_TPDO;

   214

		TestMaster_Data.post_emcy = TestMaster_post_emcy;

   215

		TestMaster_Data.post_SlaveBootup=TestMaster_post_SlaveBootup;

   216

   217

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

   218

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

   219

			goto fail_master;

   220

		}

   221

	}

   222

   223

	// Start timer thread

   224

	StartTimerLoop(&InitNodes);

   225

   226

	// wait Ctrl-C

   227

   228

	pause();

   229

   230

	eprintf("Finishing.\n");

   231

    EnterMutex();

   232

	masterSendNMTstateChange (&TestMaster_Data, 0x02, NMT_Reset_Node);

   233

    LeaveMutex();

   234

   235

	eprintf("reset\n");

   236

	// Stop master

   237

    EnterMutex();

   238

	setState(&TestMaster_Data, Stopped);

   239

    LeaveMutex();

   240

   241

	// Stop timer thread

   242

	StopTimerLoop();

   243

   244

	// Close CAN devices (and can threads)

   245

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

   246

fail_master:

   247

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

   248

fail_slave:

   249

	return 0;

   250

}