1

     2

#include "canfestival.h"

     3

     4

/* CanFestival nodes generated OD headers*/

     5

%(nodes_includes)s

     6

     7

#define BOARD_DECL(nodename, busname, baudrate)\

     8

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

     9

    10

/* CAN channels declaration */

    11

%(board_decls)s

    12

    13

/* Keep track of init level to cleanup correctly */

    14

static int init_level=0;

    15

/* Retrieve PLC cycle time */

    16

extern int common_ticktime__;

    17

    18

/* Called once all NetworkEdit declares slaves have booted*/

    19

static void Master_post_SlaveBootup(CO_Data* d, UNS8 nodeId)

    20

{

    21

    /* Put the master in operational mode */

    22

    setState(d, Operational);

    23

    24

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

    25

    masterSendNMTstateChange (d, 0, NMT_Start_Node);

    26

}

    27

    28

/* Per master node slavebootup callbacks. Checks that

    29

 * every node have booted before calling Master_post_SlaveBootup */

    30

%(slavebootups)s

    31

    32

/* One slave node post_sync callback.

    33

 * Used to align PLC tick-time on CANopen SYNC 

    34

 */

    35

%(post_sync)s

    36

    37

#define NODE_FORCE_SYNC(nodename) \

    38

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

    39

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

    40

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

    41

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

    42

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

    43

    44

#define NODE_INIT(nodename, nodeid) \

    45

    /* Defining the node Id */\

    46

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

    47

    /* init */\

    48

    setState(&nodename##_Data, Initialisation);

    49

    50

#define NODE_MASTER_INIT(nodename, nodeid) \

    51

	NODE_FORCE_SYNC(nodename) \

    52

	NODE_INIT(nodename, nodeid)

    53

    54

#define NODE_SLAVE_INIT(nodename, nodeid) \

    55

	NODE_INIT(nodename, nodeid)

    56

    57

void InitNodes(CO_Data* d, UNS32 id)

    58

{

    59

	%(slavebootup_register)s

    60

	%(post_sync_register)s

    61

    %(nodes_init)s

    62

}

    63

    64

void Exit(CO_Data* d, UNS32 id)

    65

{

    66

}

    67

    68

#define NODE_CLOSE(nodename) \

    69

    if(init_level-- > 0)\

    70

    {\

    71

        EnterMutex();\

    72

        masterSendNMTstateChange(&nodename##_Data, 0, NMT_Reset_Node);\

    73

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

    74

        LeaveMutex();\

    75

        canClose(&nodename##_Data);\

    76

    }

    77

    78

void __cleanup_%(locstr)s()

    79

{

    80

    // Stop timer thread

    81

    if(init_level-- > 0){

    82

        StopTimerLoop(&Exit);

    83

        %(nodes_close)s

    84

   }

    85

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

    86

   		TimerCleanup();

    87

    #endif

    88

}

    89

    90

#define NODE_OPEN(nodename)\

    91

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

    92

        fprintf(stderr,"Cannot open CAN intefrace %%s at speed %%s\n for CANopen node \"" #nodename "\"",nodename##Board.busname, nodename##Board.baudrate);\

    93

        fflush(stderr);\

    94

        return -1;\

    95

    }\

    96

    init_level++;

    97

    98

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

    99

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

   100

{

   101

#ifndef NOT_USE_DYNAMIC_LOADING

   102

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

   103

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

   104

        fflush(stderr);

   105

        return -1;

   106

    }

   107

#endif      

   108

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

   109

		TimerInit();

   110

	#endif

   111

   112

    %(nodes_open)s

   113

   114

    // Start timer thread

   115

    StartTimerLoop(&InitNodes);

   116

    init_level++;

   117

    return 0;

   118

}

   119

   120

#define NODE_SEND_SYNC(nodename)\

   121

    sendSYNCMessage(&nodename##_Data);

   122

   123

void __retrieve_%(locstr)s()

   124

{

   125

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

   126

     * TODO : implement buffers to avoid such a big lock  

   127

     *  */

   128

    EnterMutex();

   129

    /* Send Sync */

   130

    %(nodes_send_sync)s

   131

}

   132

   133

#define NODE_PROCEED_SYNC(nodename)\

   134

    proceedSYNC(&nodename##_Data);

   135

   136

void __publish_%(locstr)s()

   137

{

   138

    /* Process sync event */

   139

    %(nodes_proceed_sync)s

   140

    LeaveMutex();

   141

}

   142