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 <sys/time.h>

    34

//#include <unistd.h>

    35

#include <stdlib.h>

    36

#include <signal.h>

    37

#endif

    38

    39

#include <applicfg.h>

    40

#include <can_driver.h>

    41

#include <timers_driver.h>

    42

    43

#include "Master.h"

    44

#include "Slave.h"

    45

#include "TestMasterSlave.h"

    46

    47

#define MyCase(fc) case fc: eprintf(#fc);break;

    48

void print_message(Message *m)

    49

{

    50

	int i;

    51

	switch(m->cob_id.w >> 7)

    52

	{

    53

		MyCase(SYNC)

    54

		MyCase(TIME_STAMP)

    55

		MyCase(PDO1tx)

    56

		MyCase(PDO1rx)

    57

		MyCase(PDO2tx)

    58

		MyCase(PDO2rx)

    59

		MyCase(PDO3tx)

    60

		MyCase(PDO3rx)

    61

		MyCase(PDO4tx)

    62

		MyCase(PDO4rx)

    63

		MyCase(SDOtx)

    64

		MyCase(SDOrx)

    65

		MyCase(NODE_GUARD)

    66

		MyCase(NMT)

    67

	}

    68

	eprintf(" rtr:%d", m->rtr);

    69

	eprintf(" len:%d", m->len);

    70

	for (i = 0 ; i < m->len ; i++)

    71

		eprintf(" %02x", m->data[i]);

    72

	eprintf("\n");

    73

}

    74

    75

UNS32 OnMasterMap1Update(CO_Data* d, const indextable * unsused_indextable, UNS8 unsused_bSubindex)

    76

{

    77

	eprintf("OnSlaveMap1Update:%d\n", SlaveMap1);

    78

	return 0;

    79

}

    80

    81

s_BOARD SlaveBoard = {"0", "500K"};

    82

s_BOARD MasterBoard = {"1", "500K"};

    83

    84

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

    85

void catch_signal(int sig)

    86

{

    87

  signal(SIGTERM, catch_signal);

    88

  signal(SIGINT, catch_signal);

    89

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

    90

}

    91

#endif

    92

    93

void help()

    94

{

    95

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

    96

  printf("*  TestMasterSlave                                           *\n");

    97

  printf("*                                                            *\n");

    98

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

    99

  printf("*  nodes in the same process. A master and a slave. Both     *\n");

   100

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

   101

  printf("*  SDO and PDO.                                              *\n");

   102

  printf("*                                                            *\n");

   103

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

   104

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

   105

  printf("*                                                            *\n");

   106

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

   107

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

   108

  printf("*                                                            *\n");

   109

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

   110

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

   111

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

   112

  printf("*                                                            *\n");

   113

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

   114

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

   115

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

   116

  printf("*                                                            *\n");

   117

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

   118

}

   119

   120

/***************************  INIT  *****************************************/

   121

void InitNodes(CO_Data* d, UNS32 id)

   122

{

   123

	/****************************** INITIALISATION SLAVE *******************************/

   124

	if(SlaveBoard.baudrate) {

   125

		/* Defining the node Id */

   126

		setNodeId(&TestSlave_Data, 0x02);

   127

		/* init */

   128

		setState(&TestSlave_Data, Initialisation);

   129

	}

   130

   131

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

   132

	if(MasterBoard.baudrate){

   133

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

   134

   135

		/* Defining the node Id */

   136

		setNodeId(&TestMaster_Data, 0x01);

   137

   138

		/* init */

   139

		setState(&TestMaster_Data, Initialisation);

   140

   141

		/****************************** START *******************************/

   142

		/* Put the master in operational mode */

   143

		setState(&TestMaster_Data, Operational);

   144

   145

		/* Ask slave node to go in operational mode */

   146

		masterSendNMTstateChange (&TestMaster_Data, 0x02, NMT_Start_Node);

   147

	}

   148

}

   149

   150

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

   151

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

   152

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

   153

int main(int argc,char **argv)

   154

{

   155

   156

  char c;

   157

  extern char *optarg;

   158

  char* LibraryPath="libcanfestival_can_virtual.so";

   159

   160

  while ((c = getopt(argc, argv, "-m:s:M:S:l:")) != EOF)

   161

  {

   162

    switch(c)

   163

    {

   164

      case 's' :

   165

        if (optarg[0] == 0)

   166

        {

   167

          help();

   168

          exit(1);

   169

        }

   170

        SlaveBoard.busname = optarg;

   171

        break;

   172

      case 'm' :

   173

        if (optarg[0] == 0)

   174

        {

   175

          help();

   176

          exit(1);

   177

        }

   178

        MasterBoard.busname = optarg;

   179

        break;

   180

      case 'S' :

   181

        if (optarg[0] == 0)

   182

        {

   183

          help();

   184

          exit(1);

   185

        }

   186

        SlaveBoard.baudrate = optarg;

   187

        break;

   188

      case 'M' :

   189

        if (optarg[0] == 0)

   190

        {

   191

          help();

   192

          exit(1);

   193

        }

   194

        MasterBoard.baudrate = optarg;

   195

        break;

   196

      case 'l' :

   197

        if (optarg[0] == 0)

   198

        {

   199

          help();

   200

          exit(1);

   201

        }

   202

        LibraryPath = optarg;

   203

        break;

   204

      default:

   205

        help();

   206

        exit(1);

   207

    }

   208

  }

   209

   210

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

   211

  /* install signal handler for manual break */

   212

	signal(SIGTERM, catch_signal);

   213

	signal(SIGINT, catch_signal);

   214

#endif

   215

   216

#ifndef NOT_USE_DYNAMIC_LOADING

   217

	LoadCanDriver(LibraryPath);

   218

#endif		

   219

	// Open CAN devices

   220

	if(SlaveBoard.baudrate){

   221

   222

		TestSlave_Data.heartbeatError = TestSlave_heartbeatError;

   223

		TestSlave_Data.SDOtimeoutError = TestSlave_SDOtimeoutError;

   224

		TestSlave_Data.initialisation = TestSlave_initialisation;

   225

		TestSlave_Data.preOperational = TestSlave_preOperational;

   226

		TestSlave_Data.operational = TestSlave_operational;

   227

		TestSlave_Data.stopped = TestSlave_stopped;

   228

		TestSlave_Data.post_sync = TestSlave_post_sync;

   229

		TestSlave_Data.post_TPDO = TestSlave_post_TPDO;

   230

   231

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

   232

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

   233

			goto fail_slave;

   234

		}

   235

	}

   236

   237

	if(MasterBoard.baudrate){

   238

   239

		TestMaster_Data.heartbeatError = TestMaster_heartbeatError;

   240

		TestMaster_Data.SDOtimeoutError = TestMaster_SDOtimeoutError;

   241

		TestMaster_Data.initialisation = TestMaster_initialisation;

   242

		TestMaster_Data.preOperational = TestMaster_preOperational;

   243

		TestMaster_Data.operational = TestMaster_operational;

   244

		TestMaster_Data.stopped = TestMaster_stopped;

   245

		TestMaster_Data.post_sync = TestMaster_post_sync;

   246

		TestMaster_Data.post_TPDO = TestMaster_post_TPDO;

   247

   248

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

   249

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

   250

			goto fail_master;

   251

		}

   252

	}

   253

   254

	// Start timer thread

   255

	StartTimerLoop(&InitNodes);

   256

   257

	// wait Ctrl-C

   258

	pause();

   259

	eprintf("Finishing.\n");

   260

   261

	// Stop timer thread

   262

	StopTimerLoop();

   263

   264

	// Close CAN devices (and can threads)

   265

	if(SlaveBoard.baudrate) canClose(&TestSlave_Data);

   266

fail_master:

   267

	if(MasterBoard.baudrate) canClose(&TestMaster_Data);	

   268

fail_slave:

   269

   270

   271

  return 0;

   272

}