1

     2

#include "canfestival.h"

     4

     5

/* CanFestival nodes generated OD headers*/

     6

%(nodes_includes)s

     7

     8

#define BOARD_DECL(nodename, busname, baudrate)\

     9

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

    10

    11

/* CAN channels declaration */

    12

%(board_decls)s

    13

    14

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

    15

static int init_level=0;

    16

/* Retrieve PLC cycle time */

    17

extern int common_ticktime__;

    18

    19

/* Per master node slavebootup callbacks. Checks that

    20

 * every node have booted before calling Master_post_SlaveBootup */

    21

%(slavebootups)s

    22

    23

/* One slave node post_sync callback.

    24

 * Used to align PLC tick-time on CANopen SYNC

    25

 */

    26

%(post_sync)s

    27

    28

#define NODE_FORCE_SYNC(nodename) \

    29

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

    30

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

    31

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

    32

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

    33

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

    34

    35

#define NODE_INIT(nodename, nodeid) \

    36

    /* Defining the node Id */\

    37

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

    38

    /* init */\

    39

    setState(&nodename##_Data, Initialisation);

    40

    41

#define NODE_MASTER_INIT(nodename, nodeid) \

    42

    NODE_FORCE_SYNC(nodename) \

    43

    NODE_INIT(nodename, nodeid)

    44

    45

#define NODE_SLAVE_INIT(nodename, nodeid) \

    46

    NODE_INIT(nodename, nodeid)

    47

    48

void InitNodes(CO_Data* d, UNS32 id)

    49

{

    50

    %(slavebootup_register)s

    51

    %(post_sync_register)s

    52

    %(nodes_init)s

    53

}

    54

    55

#define NODE_STOP(nodename) \

    56

    if(init_level-- > 0)\

    57

    {\

    58

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

    59

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

    60

    }

    61

    62

void Exit(CO_Data* d, UNS32 id)

    63

{

    64

    %(nodes_stop)s

    65

}

    66

    67

#define NODE_CLOSE(nodename) \

    68

    if(init_level_c-- > 0)\

    69

    {\

    70

      canClose(&nodename##_Data);\

    71

    }

    72

    73

void __cleanup_%(locstr)s(void)

    74

{

    75

    // Stop timer thread

    76

    if(init_level-- > 0){

    77

    int init_level_c = init_level;

    78

        StopTimerLoop(&Exit);

    79

        %(nodes_close)s

    80

    }

    81

    82

    TimerCleanup();

    83

}

    84

    85

#ifndef stderr

    86

#define fprintf(...)

    87

#define fflush(...)

    88

#endif

    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

   109

    TimerInit();

   110

   111

    %(nodes_open)s

   112

   113

    // Start timer thread

   114

    StartTimerLoop(&InitNodes);

   115

    init_level++;

   116

    return 0;

   117

}

   118

   119

#define NODE_SEND_SYNC(nodename)\

   123

   124

void __retrieve_%(locstr)s(void)

   125

{

   126

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

   127

     * TODO : implement buffers to avoid such a big lock

   128

     *  */

   129

    EnterMutex();

   130

    /* Send Sync */

   131

    %(nodes_send_sync)s

   132

}

   133

   134

#define NODE_PROCEED_SYNC(nodename)\

   135

    proceedSYNC(&nodename##_Data);

   136

   137

void __publish_%(locstr)s(void)

   138

{

   139

    /* Process sync event */

   140

    %(nodes_proceed_sync)s

   141

    LeaveMutex();

   142

}

   143