1

#include "canfestival.h"

     2

     3

#include "Master.h"

     4

#include "Slave.h"

     5

#include "TestMasterSlave.h"

     6

     7

     8

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

     9

{

    10

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

    11

	return 0;

    12

}

    13

    14

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

    15

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

    16

    17

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

    18

static void InitNodes(CO_Data* d, UNS32 id)

    19

{

    20

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

    21

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

    22

		setNodeId(&TestSlave_Data, 0x02);

    23

    24

		setState(&TestSlave_Data, Initialisation);

    25

	}

    26

    27

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

    28

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

    29

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

    30

    31

		// Defining the node Id

    32

		setNodeId(&TestMaster_Data, 0x01);

    33

    34

		setState(&TestMaster_Data, Initialisation);

    35

	}

    36

}

    37

    38

/***************************  EXIT  *****************************************/

    39

void Exit(CO_Data* d, UNS32 id)

    40

{

    41

	masterSendNMTstateChange(&TestMaster_Data, 0x02, NMT_Reset_Node);    

    42

    43

	//Stop master

    44

	setState(&TestMaster_Data, Stopped);

    45

}

    46

    47

    48

int TestMasterSlave_start (void)

    49

{

    50

	TimerInit();

    51

    52

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

    53

    54

		TestSlave_Data.heartbeatError = TestSlave_heartbeatError;

    55

		TestSlave_Data.initialisation = TestSlave_initialisation;

    56

		TestSlave_Data.preOperational = TestSlave_preOperational;

    57

		TestSlave_Data.operational = TestSlave_operational;

    58

		TestSlave_Data.stopped = TestSlave_stopped;

    59

		TestSlave_Data.post_sync = TestSlave_post_sync;

    60

		TestSlave_Data.post_TPDO = TestSlave_post_TPDO;

    61

		TestSlave_Data.storeODSubIndex = TestSlave_storeODSubIndex;

    62

		TestSlave_Data.post_emcy = TestSlave_post_emcy;

    63

    64

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

    65

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

    66

			return 1;

    67

		}

    68

	}

    69

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

    70

    71

		TestMaster_Data.heartbeatError = TestMaster_heartbeatError;

    72

		TestMaster_Data.initialisation = TestMaster_initialisation;

    73

		TestMaster_Data.preOperational = TestMaster_preOperational;

    74

		TestMaster_Data.operational = TestMaster_operational;

    75

		TestMaster_Data.stopped = TestMaster_stopped;

    76

		TestMaster_Data.post_sync = TestMaster_post_sync;

    77

		TestMaster_Data.post_TPDO = TestMaster_post_TPDO;

    78

		TestMaster_Data.post_emcy = TestMaster_post_emcy;

    79

		TestMaster_Data.post_SlaveBootup=TestMaster_post_SlaveBootup;

    80

    81

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

    82

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

    83

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

    84

			return 1;

    85

		}

    86

	}

    87

    88

	// Start timer thread

    89

	StartTimerLoop(&InitNodes);

    90

    91

	return 0;

    92

}

    93

    94

void TestMasterSlave_stop (void)

    95

{

    96

	eprintf("Finishing.\n");

    97

    98

	// Stop timer thread

    99

	StopTimerLoop(&Exit);

   100

   101

	// Close CAN devices (and can threads)

   102

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

   103

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

   104

   105

	TimerCleanup();

   106

	eprintf("End.\n");

   107

}