1

     2

#include "canfestival.h"

     3

     4

%(nodes_includes)s

     5

     6

#define BOARD_DECL(nodename, busname, baudrate)\

     7

    s_BOARD nodename##Board = {busname, baudrate};

     8

     9

%(board_decls)s

    10

    11

static int init_level=0;

    12

extern int common_ticktime__;

    13

    14

    15

static void ConfigureSlaveNode(CO_Data* d, UNS8 nodeId)

    16

{

    17

    /* Put the master in operational mode */

    18

    setState(d, Operational);

    19

    20

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

    21

    masterSendNMTstateChange (d, 0, NMT_Start_Node);

    22

}

    23

    24

#define NODE_DECLARE(nodename, nodeid)\

    25

void nodename##_preOperational()\

    26

{\

    27

    ConfigureSlaveNode(&nodename##_Data, nodeid);\

    28

}\

    29

    30

%(nodes_declare)s

    31

    32

    33

#define NODE_INIT(nodename, nodeid) \

    34

    /* Artificially force sync state to 1 so that it is not started */\

    35

    nodename##_Data.CurrentCommunicationState.csSYNC = -1;\

    36

    /* Force sync period to common_ticktime__ so that other node can read it*/\

    37

    *nodename##_Data.COB_ID_Sync = 0x40000080;\

    38

    *nodename##_Data.Sync_Cycle_Period = common_ticktime__ * 1000;\

    39

    /* Defining the node Id */\

    40

    setNodeId(&nodename##_Data, nodeid);\

    41

    /* init */\

    42

    setState(&nodename##_Data, Initialisation);

    43

    44

void InitNodes(CO_Data* d, UNS32 id)

    45

{

    46

    %(nodes_init)s

    47

}

    48

    49

void Exit(CO_Data* d, UNS32 id)

    50

{

    51

}

    52

    53

#define NODE_CLOSE(nodename) \

    54

    if(init_level-- > 0)\

    55

    {\

    56

        EnterMutex();\

    57

        setState(&nodename##_Data, Stopped);\

    58

        LeaveMutex();\

    59

        canClose(&nodename##_Data);\

    60

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

    61

        		TimerCleanup();\

    62

        #endif\

    63

    }

    64

    65

void __cleanup_%(locstr)s()

    66

{

    67

    %(nodes_close)s

    68

    69

    // Stop timer thread

    70

    if(init_level-- > 0)

    71

        StopTimerLoop(&Exit);

    72

    73

}

    74

    75

#define NODE_OPEN(nodename)\

    76

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

    77

		TimerInit();\

    78

	#endif\

    79

	nodename##_Data.preOperational = nodename##_preOperational;\

    80

    if(!canOpen(&nodename##Board,&nodename##_Data)){\

    81

        printf("Cannot open " #nodename " Board (%%s,%%s)\n",nodename##Board.busname, nodename##Board.baudrate);\

    82

        return -1;\

    83

    }\

    84

    init_level++;

    85

    86

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

    87

int __init_%(locstr)s(int argc,char **argv)

    88

{

    89

#ifndef NOT_USE_DYNAMIC_LOADING

    90

    if( !LoadCanDriver("%(candriver)s") ){

    91

        fprintf(stderr, "Cannot load CAN interface library for CanFestival (%(candriver)s)\n");\

    92

        return -1;

    93

    }

    94

#endif      

    95

    96

    %(nodes_open)s

    97

    98

    // Start timer thread

    99

    StartTimerLoop(&InitNodes);

   100

    init_level++;

   101

    return 0;

   102

}

   103

   104

#define NODE_SEND_SYNC(nodename)\

   105

    sendSYNCMessage(&nodename##_Data);

   106

   107

void __retrieve_%(locstr)s()

   108

{

   109

    /* Locks the stack, so that no changes occurs while PLC access variables

   110

     * TODO : implement buffers to avoid such a big lock  

   111

     *  */

   112

    EnterMutex();

   113

    /*Send Sync */

   114

    %(nodes_send_sync)s

   115

}

   116

   117

#define NODE_PROCEED_SYNC(nodename)\

   118

    proceedSYNC(&nodename##_Data);

   119

   120

void __publish_%(locstr)s()

   121

{

   122

    /*Call SendPDOEvent */

   123

    %(nodes_proceed_sync)s

   124

    LeaveMutex();

   125

}

   126