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

#include <stdio.h>

    24

#include <string.h>

    25

#include <sys/time.h>

    26

#include <unistd.h>

    27

#include <stdlib.h>

    28

#include <signal.h>

    29

    30

#include <applicfg.h>

    31

#include <can_driver.h>

    32

#include <timers_driver.h>

    33

    34

#include "Master.h"

    35

#include "Slave.h"

    36

#include "TestMasterSlave.h"

    37

    38

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

    39

void print_message(Message *m)

    40

{

    41

	int i;

    42

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

    43

	{

    44

		MyCase(SYNC)

    45

		MyCase(TIME_STAMP)

    46

		MyCase(PDO1tx)

    47

		MyCase(PDO1rx)

    48

		MyCase(PDO2tx)

    49

		MyCase(PDO2rx)

    50

		MyCase(PDO3tx)

    51

		MyCase(PDO3rx)

    52

		MyCase(PDO4tx)

    53

		MyCase(PDO4rx)

    54

		MyCase(SDOtx)

    55

		MyCase(SDOrx)

    56

		MyCase(NODE_GUARD)

    57

		MyCase(NMT)

    58

	}

    59

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

    60

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

    61

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

    62

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

    63

	eprintf("\n");

    64

}

    65

    66

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

    67

{

    68

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

    69

	return 0;

    70

}

    71

    72

CAN_HANDLE SlaveCanHandle;

    73

CAN_HANDLE MasterCanHandle;

    74

    75

// Baudrate values for Peak board :

    76

// CAN_BAUD_1M CAN_BAUD_500K CAN_BAUD_250K CAN_BAUD_125K CAN_BAUD_100K CAN_BAUD_50K

    77

// CAN_BAUD_20K CAN_BAUD_10K CAN_BAUD_5K

    78

    79

#ifdef CAN_BAUD_500K

    80

int TranslateBaudeRate(char* optarg){

    81

	if(!strcmp( optarg, "1M")) return CAN_BAUD_1M;

    82

	if(!strcmp( optarg, "500K")) return CAN_BAUD_500K;

    83

	if(!strcmp( optarg, "250K")) return CAN_BAUD_250K;

    84

	if(!strcmp( optarg, "125K")) return CAN_BAUD_125K;

    85

	if(!strcmp( optarg, "100K")) return CAN_BAUD_100K;

    86

	if(!strcmp( optarg, "50K")) return CAN_BAUD_50K;

    87

	if(!strcmp( optarg, "20K")) return CAN_BAUD_20K;

    88

	if(!strcmp( optarg, "10K")) return CAN_BAUD_10K;

    89

	if(!strcmp( optarg, "5K")) return CAN_BAUD_5K;

    90

	if(!strcmp( optarg, "none")) return 0;

    91

	return 0x0000;

    92

}

    93

s_BOARD SlaveBoard = {"0", CAN_BAUD_500K, &TestSlave_Data};

    94

s_BOARD MasterBoard = {"1", CAN_BAUD_500K, &TestMaster_Data};

    95

#else

    96

int TranslateBaudeRate(char* optarg){

    97

	if(!strcmp( optarg, "1M")) return 1000;

    98

	if(!strcmp( optarg, "500K")) return 500;

    99

	if(!strcmp( optarg, "250K")) return 250;

   100

	if(!strcmp( optarg, "125K")) return 125;

   101

	if(!strcmp( optarg, "100K")) return 100;

   102

	if(!strcmp( optarg, "50K")) return 50;

   103

	if(!strcmp( optarg, "20K")) return 20;

   104

	if(!strcmp( optarg, "10K")) return 10;

   105

	if(!strcmp( optarg, "5K")) return 5;

   106

	if(!strcmp( optarg, "none")) return 0;

   107

	return 0;

   108

}

   109

s_BOARD SlaveBoard = {"0", 500, &TestSlave_Data};

   110

s_BOARD MasterBoard = {"1", 500, &TestMaster_Data};

   111

#endif

   112

   113

   114

void catch_signal(int sig)

   115

{

   116

  signal(SIGTERM, catch_signal);

   117

  signal(SIGINT, catch_signal);

   118

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

   119

}

   120

   121

void help()

   122

{

   123

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

   124

  printf("*  TestMasterSlave                                           *\n");

   125

  printf("*                                                            *\n");

   126

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

   127

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

   128

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

   129

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

   130

  printf("*                                                            *\n");

   131

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

   132

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

   133

  printf("*                                                            *\n");

   134

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

   135

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

   136

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

   137

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

   138

  printf("*                                                            *\n");

   139

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

   140

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

   141

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

   142

  printf("*                                                            *\n");

   143

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

   144

}

   145

   146

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

   147

void InitNodes(CO_Data* d, UNS32 id)

   148

{

   149

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

   150

	if(SlaveBoard.baudrate) {

   151

		/* Defining the node Id */

   152

		setNodeId(&TestSlave_Data, 0x02);

   153

		/* init */

   154

		setState(&TestSlave_Data, Initialisation);

   155

	}

   156

   157

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

   158

	if(MasterBoard.baudrate){

   159

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

   160

   161

		/* Defining the node Id */

   162

		setNodeId(&TestMaster_Data, 0x01);

   163

   164

		/* init */

   165

		setState(&TestMaster_Data, Initialisation);

   166

   167

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

   168

		/* Put the master in operational mode */

   169

		setState(&TestMaster_Data, Operational);

   170

   171

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

   172

		masterSendNMTstateChange (&TestMaster_Data, 0x02, NMT_Start_Node);

   173

	}

   174

}

   175

   176

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

   177

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

   178

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

   179

int main(int argc,char **argv)

   180

{

   181

   182

  char c;

   183

  extern char *optarg;

   184

   185

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

   186

  {

   187

    switch(c)

   188

    {

   189

      case 's' :

   190

        if (optarg[0] == 0)

   191

        {

   192

          help();

   193

          exit(1);

   194

        }

   195

        SlaveBoard.busname = optarg;

   196

        break;

   197

      case 'm' :

   198

        if (optarg[0] == 0)

   199

        {

   200

          help();

   201

          exit(1);

   202

        }

   203

        MasterBoard.busname = optarg;

   204

        break;

   205

      case 'S' :

   206

        if (optarg[0] == 0)

   207

        {

   208

          help();

   209

          exit(1);

   210

        }

   211

        SlaveBoard.baudrate = TranslateBaudeRate(optarg);

   212

        break;

   213

      case 'M' :

   214

        if (optarg[0] == 0)

   215

        {

   216

          help();

   217

          exit(1);

   218

        }

   219

        MasterBoard.baudrate = TranslateBaudeRate(optarg);

   220

        break;

   221

      default:

   222

        help();

   223

        exit(1);

   224

    }

   225

  }

   226

   227

	/* install signal handler for manual break */

   228

	signal(SIGTERM, catch_signal);

   229

	signal(SIGINT, catch_signal);

   230

   231

	// Open CAN devices

   232

	if(SlaveBoard.baudrate)

   233

		if((SlaveCanHandle = canOpen(&SlaveBoard))==NULL) goto fail_slave;

   234

   235

	if(MasterBoard.baudrate)

   236

		if((MasterCanHandle = canOpen(&MasterBoard))==NULL) goto fail_master;

   237

   238

	// Start timer thread

   239

	StartTimerLoop(&InitNodes);

   240

   241

	// wait Ctrl-C

   242

	pause();

   243

	eprintf("Finishing.\n");

   244

   245

	// Stop timer thread

   246

	StopTimerLoop();

   247

   248

	// Close CAN devices (and can threads)

   249

	if(SlaveBoard.baudrate) canClose(SlaveCanHandle);

   250

fail_master:

   251

	if(MasterBoard.baudrate) canClose(MasterCanHandle);	

   252

fail_slave:

   253

   254

   255

  return 0;

   256

}