11

# Definition of node variables that have to be mapped in PDO

    12

# [(name, index, subindex, type, 

    13

#   direction for master ('I': input, 'Q': output)),...]

    15

    ("ControlWord",             0x6040, 0x00, "UINT", "Q"),

    16

    ("TargetPosition",          0x607a, 0x00, "DINT", "Q"),

    17

    ("TargetVelocity",          0x60ff, 0x00, "DINT", "Q"),

    18

    ("TargetTorque",            0x6071, 0x00, "INT",  "Q"),

    19

    ("ModesOfOperation",        0x6060, 0x00, "SINT", "Q"),

    20

    ("StatusWord",              0x6041, 0x00, "UINT", "I"),

    21

    ("ModesOfOperationDisplay", 0x6061, 0x00, "SINT", "I"),

    22

    ("ActualPosition",          0x6064, 0x00, "DINT", "I"),

    23

    ("ActualVelocity",          0x606c, 0x00, "DINT", "I"),

    24

    ("ActualTorque",            0x6077, 0x00, "INT",  "I"),

    27

# Definition of optional node variables that can be added to PDO mapping.

    28

# A checkbox will be displayed for each section in node configuration panel to

    29

# enable them

    30

# [(section_name, 

    31

#   [{'description', (name, index, subindex, type, 

    32

#                     direction for master ('I': input, 'Q': output)),

    33

#     'retrieve', string_template_for_retrieve_variable (None: not retrieved, 

    34

#                                 default string template if not defined),

    35

#     'publish', string_template_for_publish_variable (None: not published, 

    36

#                                 default string template if not defined),

    37

#    },...]

    62

    63

# List of parameters name in no configuration panel for optional variable

    64

# sections

    65

EXTRA_NODE_VARIABLES_DICT = {

    66

    "Enable" + name: params 

    67

    for name, params in EXTRA_NODE_VARIABLES}

    68

    69

# List of block to define to interface MCL to fieldbus for specific functions

    70

FIELDBUS_INTERFACE_GLOBAL_INSTANCES = [

    94

    """ % ("\n".join(["""\

    95

          <xsd:attribute name="Enable%s" type="xsd:boolean"

    96

                         use="optional" default="false"/>""" % category 

    97

                for category, variables in EXTRA_NODE_VARIABLES]) + AxisXSD)

   108

    ]

   148

        return [("%s_%s" % (block_infos["blocktype"], 

   149

                            "_".join(map(str, current_location))),

   150

                 "EtherLab%s" % block_infos["blocktype"], "") 

   151

                for block_infos in FIELDBUS_INTERFACE_GLOBAL_INSTANCES]

   154

        data = wx.TextDataObject(str(

   155

            ("%%IW%s.0" % ".".join(map(str, self.GetCurrentLocation())), 

   156

             "location", "AXIS_REF", self.CTNName(), "")))

   165

        slave_pos = self.GetSlavePos()

   166

        MCL_headers = Headers

   167

   168

        # Open CIA402 node code template file 

   169

        plc_cia402node_filepath = os.path.join(os.path.split(__file__)[0], 

   170

                                               "plc_cia402node.c")

   175

        # Init list of generated strings for each code template file section

   176

        fieldbus_interface_declaration = []

   177

        fieldbus_interface_definition = []

   178

        init_axis_params = []

   179

        extra_variables_retrieve = []

   180

        extra_variables_publish = []

   181

        extern_located_variables_declaration = []

   182

        entry_variables = []

   183

        init_entry_variables = []

   184

   185

        # Fieldbus interface code sections

   186

        for blocktype_infos in FIELDBUS_INTERFACE_GLOBAL_INSTANCES:

   187

            blocktype = blocktype_infos["blocktype"]

   188

            ucase_blocktype = blocktype.upper()

   189

            blockname = "_".join([ucase_blocktype, location_str])

   190

   191

            extract_inputs = "\n".join(["""\

   192

    __SET_VAR(%s->, %s, %s);""" % (blockname, input_name, input_value)

   193

                for (input_name, input_value) in [

   194

                    ("EXECUTE", "__GET_VAR(data__->EXECUTE)")] + [

   195

                    (input["name"].upper(), 

   196

                     "__GET_VAR(data__->%s)" % input["name"].upper())

   197

                    for input in blocktype_infos["inputs"]]

   198

                ])

   199

   200

   201

            return_outputs = "\n".join(["""\

   202

    __SET_VAR(data__->,%(output_name)s, 

   203

              __GET_VAR(%(blockname)s->%(output_name)s));""" % locals()

   204

                    for output_name in ["DONE", "BUSY", "ERROR"] + [

   205

                        output["name"].upper()

   206

                        for output in blocktype_infos["outputs"]]

   207

                ])

   208

   209

            fieldbus_interface_declaration.append("""

   210

extern void ETHERLAB%(ucase_blocktype)s_body__(ETHERLAB%(ucase_blocktype)s* data__);

   211

void __%(blocktype)s_%(location_str)s(MC_%(ucase_blocktype)s *data__) {

   212

__DECLARE_GLOBAL_PROTOTYPE(ETHERLAB%(ucase_blocktype)s, %(blockname)s);

   213

ETHERLAB%(ucase_blocktype)s* %(blockname)s = __GET_GLOBAL_%(blockname)s();

   214

__SET_VAR(%(blockname)s->, POS, AxsPub.axis->NetworkPosition);

   215

%(extract_inputs)s

   216

ETHERLAB%(ucase_blocktype)s_body__(%(blockname)s);

   217

%(return_outputs)s

   218

}""" % locals())

   219

   220

            fieldbus_interface_definition.append("""\

   221

        AxsPub.axis->__mcl_func_MC_%(blocktype)s = __%(blocktype)s_%(location_str)s;\

   222

""" % locals())

   223

   224

        # Get a copy list of default variables to map

   227

        # Set AxisRef public struct members value

   228

        node_params = self.CTNParams[1].getElementInfos(self.CTNParams[0])

   229

        for param in node_params["children"]:

   230

            param_name = param["name"]

   231

   232

            # Param is optional variables section enable flag

   233

            extra_node_variable_infos = EXTRA_NODE_VARIABLES_DICT.get(param_name)

   234

            if extra_node_variable_infos is not None:

   235

   236

                if not param["value"]:

   237

                    continue

   238

   239

                # Optional variables section is enabled

   240

                for variable_infos in extra_node_variable_infos:

   241

                    var_name = variable_infos["description"][0]

   242

   243

                    # Add each variables defined in section description to the

   244

                    # list of variables to map

   245

                    variables.append(variable_infos["description"])

   246

   247

                    # Add code to publish or retrive variable

   248

                    for var_exchange_dir, str_list, default_template in [

   249

                         ("retrieve", extra_variables_retrieve,

   250

                          "    AxsPub.axis->%(var_name)s = *(AxsPub.%(var_name)s);"),

   251

                         ("publish", extra_variables_publish,

   252

                          "    *(AxsPub.%(var_name)s) = AxsPub.axis->%(var_name)s;")]:

   254

                        template = variable_infos.get(var_exchange_dir, 

   255

                                                      default_template)

   256

                        if template is not None:

   257

                            extra_variables_publish.append(template % locals())

   258

   259

            # Set AxisRef public struct member value if defined

   261

                param_value = ({True: "1", False: "0"}[param["value"]]

   262

                               if param["type"] == "boolean"

   263

                               else str(param["value"]))

   264

   265

                init_axis_params.append("""\

   266

        AxsPub.axis->%(param_name)s = %(param_value)s;""" % locals())

   267

   268

        # Add each variable in list of variables to map to master list of

   269

        # variables to add to network configuration

   270

        for name, index, subindex, var_type, dir in variables:

   271

            var_size = self.GetSizeOfType(var_type)

   272

            var_name = """\

   273

__%(dir)s%(var_size)s%(location_str)s_%(index)d_%(subindex)d""" % locals()

   274

   275

            extern_located_variables_declaration.append(

   276

                    "IEC_%(var_type)s *%(var_name)s;" % locals())

   277

            entry_variables.append(

   278

                    "    IEC_%(var_type)s *%(name)s;" % locals())

   279

            init_entry_variables.append(

   280

                    "    AxsPub.%(name)s = %(var_name)s;" % locals())

   283

                    slave_pos, index, subindex, var_type, dir, var_name)

   284

   285

        # Add newline between string in list of generated strings for sections

   286

        [fieldbus_interface_declaration, fieldbus_interface_definition,

   287

         init_axis_params, extra_variables_retrieve, extra_variables_publish,

   288

         extern_located_variables_declaration, entry_variables, 

   289

         init_entry_variables] = map(lambda l: "\n".join(l), [

   290

            fieldbus_interface_declaration, fieldbus_interface_definition,

   291

            init_axis_params, extra_variables_retrieve, extra_variables_publish,

   292

            extern_located_variables_declaration, entry_variables, 

   293

            init_entry_variables])

   294

   295

        # Write generated content to CIA402 node file

   296

        Gen_CIA402Nodefile_path = os.path.join(buildpath, 

   297

                                "cia402node_%s.c"%location_str)

   299

        cia402nodefile.write(plc_cia402node_code % locals())