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

	TimerInit();

   193

#endif

   194

   195

#ifndef NOT_USE_DYNAMIC_LOADING

   196

	if (LoadCanDriver(LibraryPath) == NULL)

   197

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

   198

#endif		

   199

	// Open CAN devices

   200

   201

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

   202

   203

		TestSlave_Data.heartbeatError = TestSlave_heartbeatError;

   204

		TestSlave_Data.initialisation = TestSlave_initialisation;

   205

		TestSlave_Data.preOperational = TestSlave_preOperational;

   206

		TestSlave_Data.operational = TestSlave_operational;

   207

		TestSlave_Data.stopped = TestSlave_stopped;

   208

		TestSlave_Data.post_sync = TestSlave_post_sync;

   209

		TestSlave_Data.post_TPDO = TestSlave_post_TPDO;

   210

		TestSlave_Data.storeODSubIndex = TestSlave_storeODSubIndex;

   211

		TestSlave_Data.post_emcy = TestSlave_post_emcy;

   212

   213

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

   214

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

   215

			goto fail_slave;

   216

		}

   217

	}

   218

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

   219

   220

		TestMaster_Data.heartbeatError = TestMaster_heartbeatError;

   221

		TestMaster_Data.initialisation = TestMaster_initialisation;

   222

		TestMaster_Data.preOperational = TestMaster_preOperational;

   223

		TestMaster_Data.operational = TestMaster_operational;

   224

		TestMaster_Data.stopped = TestMaster_stopped;

   225

		TestMaster_Data.post_sync = TestMaster_post_sync;

   226

		TestMaster_Data.post_TPDO = TestMaster_post_TPDO;

   227

		TestMaster_Data.post_emcy = TestMaster_post_emcy;

   228

		TestMaster_Data.post_SlaveBootup=TestMaster_post_SlaveBootup;

   229

   230

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

   231

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

   232

			goto fail_master;

   233

		}

   234

	}

   235

   236

	// Start timer thread

   237

	StartTimerLoop(&InitNodes);

   238

   239

	// wait Ctrl-C

   240

	pause();

   241

   242

	// Stop timer thread

   243

	StopTimerLoop(&Exit);

   244

   245

	// Close CAN devices (and can threads)

   246

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

   247

fail_master:

   248

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

   249

fail_slave:

   250

	TimerCleanup();

   251

	return 0;

   252

}