1

     2

#include "canfestival.h"

     3

#include "dcf.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 unsigned long long 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

/* Triggers DCF transission

    29

 */

    30

%(pre_op)s

    31

    32

#define NODE_FORCE_SYNC(nodename) \

    33

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

    34

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

    35

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

    36

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

    37

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

    38

    39

static void DeferedInitAlarm(CO_Data* d, UNS32 id){

    40

    /* Node will start beeing active on the network after this */

    41

    setState(d, Initialisation);

    42

}

    43

    44

#define NODE_INIT(nodename, nodeid) \

    45

    /* Defining the node Id */\

    46

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

    47

    SetAlarm(&nodename##_Data,0,&DeferedInitAlarm,MS_TO_TIMEVAL(100),0);

    48

    49

#define NODE_MASTER_INIT(nodename, nodeid) \

    50

    NODE_FORCE_SYNC(nodename) \

    51

    NODE_INIT(nodename, nodeid)

    52

    53

#define NODE_SLAVE_INIT(nodename, nodeid) \

    54

    NODE_INIT(nodename, nodeid)

    55

    56

static void InitNodes(CO_Data* d, UNS32 id)

    57

{

    58

    %(slavebootup_register)s

    59

    %(post_sync_register)s

    60

    %(pre_op_register)s

    61

    %(nodes_init)s

    62

}

    63

    64

#define NODE_STOP(nodename) \

    65

    if(init_level-- > 0)\

    66

    {\

    67

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

    68

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

    69

    }

    70

    71

static void Exit(CO_Data* d, UNS32 id)

    72

{

    73

    %(nodes_stop)s

    74

}

    75

    76

#define NODE_CLOSE(nodename) \

    77

    if(init_level_c-- > 0)\

    78

    {\

    79

      canClose(&nodename##_Data);\

    80

    }

    81

    82

void __cleanup_%(locstr)s(void)

    83

{

    84

    // Stop timer thread

    85

    if(init_level-- > 0){

    86

    int init_level_c = init_level;

    87

        StopTimerLoop(&Exit);

    88

        %(nodes_close)s

    89

    }

    90

    91

    TimerCleanup();

    92

}

    93

    94

#ifndef stderr

    95

#define fprintf(...)

    96

#define fflush(...)

    97

#endif

    98

    99

#define NODE_OPEN(nodename)\

   100

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

   101

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

   102

        fflush(stderr);\

   103

        return -1;\

   104

    }\

   105

    init_level++;

   106

   107

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

   108

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

   109

{

   110

#ifndef NOT_USE_DYNAMIC_LOADING

   111

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

   112

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

   113

        fflush(stderr);\

   114

        return -1;\

   115

    }

   116

#endif

   117

   118

    TimerInit();

   119

   120

    %(nodes_open)s

   121

   122

    // Start timer thread

   123

    StartTimerLoop(&InitNodes);

   124

    init_level++;

   125

    return 0;

   126

}

   127

   128

#define NODE_SEND_SYNC(nodename)\

   129

    if(getState(&nodename##_Data)==Operational){\

   130

        sendSYNCMessage(&nodename##_Data);\

   131

    }

   132

   133

void __retrieve_%(locstr)s(void)

   134

{

   135

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

   136

     * TODO : implement buffers to avoid such a big lock

   137

     *  */

   138

    EnterMutex();

   139

    /* Send Sync */

   140

    %(nodes_send_sync)s

   141

}

   142

   143

#define NODE_PROCEED_SYNC(nodename)\

   144

    proceedSYNC(&nodename##_Data);

   145

   146

void __publish_%(locstr)s(void)

   147

{

   148

    /* Process sync event */

   149

    %(nodes_proceed_sync)s

   150

    LeaveMutex();

   151

}

   152