1

import os

     2

     3

import wx

     4

     5

from PLCControler import LOCATION_CONFNODE, LOCATION_MODULE, LOCATION_GROUP, LOCATION_VAR_INPUT, LOCATION_VAR_OUTPUT, LOCATION_VAR_MEMORY

     6

     7

from MotionLibrary import Headers, AxisXSD

     8

from EthercatSlave import _EthercatSlaveCTN, _CommonSlave

     9

from ConfigEditor import CIA402NodeEditor

    10

    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)),...]

    14

NODE_VARIABLES = [

    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"),

    25

]

    26

    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

#    },...]

    38

EXTRA_NODE_VARIABLES = [

    39

    ("ErrorCode", [

    40

        {"description": ("ErrorCode", 0x603F, 0x00, "UINT", "I"),

    41

         "publish": None}

    42

        ]),

    43

    ("DigitalInputs", [

    44

        {"description": ("DigitalInputs", 0x60FD, 0x00, "UDINT", "I"),

    45

         "publish": None}

    46

        ]),

    47

    ("DigitalOutputs", [

    48

        {"description": ("DigitalOutputs", 0x60FE, 0x00, "UDINT", "Q"),

    49

         "retrieve": None}

    50

        ]),

    51

    ("TouchProbe", [

    52

        {"description": ("TouchProbeFunction", 0x60B8, 0x00, "UINT", "Q"),

    53

         "retrieve": None},

    54

        {"description": ("TouchProbeStatus", 0x60B9, 0x00, "UINT", "I"),

    55

         "publish": None},

    56

        {"description": ("TouchProbePos1PosValue", 0x60BA, 0x00, "DINT", "I"),

    57

         "publish": None},

    58

        {"description": ("TouchProbePos1NegValue", 0x60BB, 0x00, "DINT", "I"),

    59

         "publish": None},

    60

        ]),

    61

]

    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 = [

    71

    {"blocktype": "GetTorqueLimit", 

    72

     "inputs": [],

    73

     "outputs": [{"name": "TorqueLimitPos", "type": "UINT"},

    74

                 {"name": "TorqueLimitNeg", "type": "UINT"}]},

    75

    {"blocktype": "SetTorqueLimit", 

    76

     "inputs": [{"name": "TorqueLimitPos", "type": "UINT"},

    77

                {"name": "TorqueLimitNeg", "type": "UINT"}],

    78

     "outputs": []},

    79

]

    80

    81

#--------------------------------------------------

    82

#                 Ethercat CIA402 Node

    83

#--------------------------------------------------

    84

    85

class _EthercatCIA402SlaveCTN(_EthercatSlaveCTN):

    86

    XSD = """<?xml version="1.0" encoding="ISO-8859-1" ?>

    87

    <xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema">

    88

      <xsd:element name="CIA402SlaveParams">

    89

        <xsd:complexType>

    90

          %s

    91

        </xsd:complexType>

    92

      </xsd:element>

    93

    </xsd:schema>

    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)

    98

    99

    NODE_PROFILE = 402

   100

    EditorType = CIA402NodeEditor

   101

   102

    ConfNodeMethods = [

   103

        {"bitmap" : "CIA402AxisRef",

   104

         "name" : _("Axis Ref"),

   105

         "tooltip" : _("Initiate Drag'n drop of Axis ref located variable"),

   106

         "method" : "_getCIA402AxisRef",

   107

         "push": True},

   113

    ]

   114

   115

#--------------------------------------------------

   116

#    class code

   117

#--------------------------------------------------    

   118

   119

    def __init__(self):

   120

        # ----------- call ethercat mng. function --------------

   121

        self.CommonMethod = _CommonSlave(self)

   122

   123

    def GetIconName(self):

   124

        return "CIA402Slave"

   125

   126

    def SetParamsAttribute(self, path, value):

   127

        if path == "CIA402SlaveParams.Type":

   128

            path = "SlaveParams.Type"

   129

        elif path == "CIA402SlaveParams.Alias":

   130

            path = "SlaveParams.Alias"

   131

        return _EthercatSlaveCTN.SetParamsAttribute(self, path, value)

   132

   133

    def GetVariableLocationTree(self):

   134

        axis_name = self.CTNName()

   135

        current_location = self.GetCurrentLocation()

   145

                     "type": LOCATION_VAR_INPUT,

   146

                     "size": "W",

   147

                     "IEC_type": "AXIS_REF",

   148

                     "var_name": axis_name,

   150

                     "description": "",

   151

                     "children": []}]

   152

        children.extend(self.CTNParent.GetDeviceLocationTree(self.GetSlavePos(), current_location, axis_name))

   153

        return  {"name": axis_name,

   154

                 "type": LOCATION_CONFNODE,

   155

                 "location": self.GetFullIEC_Channel(),

   156

                 "children": children,

   157

        }

   158

   159

    def CTNGlobalInstances(self):

   160

        current_location = self.GetCurrentLocation()

   161

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

   162

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

   163

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

   164

                for block_infos in FIELDBUS_INTERFACE_GLOBAL_INSTANCES]

   165

   177

    def _getCIA402AxisRef(self):

   182

    def CTNGenerate_C(self, buildpath, locations):

   183

        current_location = self.GetCurrentLocation()

   184

   185

        location_str = "_".join(map(lambda x:str(x), current_location))

   186

        slave_pos = self.GetSlavePos()

   187

        MCL_headers = Headers

   188

   189

        # Open CIA402 node code template file 

   190

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

   191

                                               "plc_cia402node.c")

   192

        plc_cia402node_file = open(plc_cia402node_filepath, 'r')

   193

        plc_cia402node_code = plc_cia402node_file.read()

   194

        plc_cia402node_file.close()

   195

   196

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

   197

        fieldbus_interface_declaration = []

   198

        fieldbus_interface_definition = []

   199

        init_axis_params = []

   200

        extra_variables_retrieve = []

   201

        extra_variables_publish = []

   202

        extern_located_variables_declaration = []

   203

        entry_variables = []

   204

        init_entry_variables = []

   205

   206

        # Fieldbus interface code sections

   207

        for blocktype_infos in FIELDBUS_INTERFACE_GLOBAL_INSTANCES:

   208

            blocktype = blocktype_infos["blocktype"]

   209

            ucase_blocktype = blocktype.upper()

   210

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

   211

   212

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

   213

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

   214

                for (input_name, input_value) in [

   215

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

   216

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

   217

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

   218

                    for input in blocktype_infos["inputs"]]

   219

                ])

   220

   221

   222

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

   223

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

   224

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

   225

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

   226

                        output["name"].upper()

   227

                        for output in blocktype_infos["outputs"]]

   228

                ])

   229

   230

            fieldbus_interface_declaration.append("""

   231

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

   232

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

   233

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

   234

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

   235

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

   236

%(extract_inputs)s

   237

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

   238

%(return_outputs)s

   239

}""" % locals())

   240

   241

            fieldbus_interface_definition.append("""\

   242

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

   243

""" % locals())

   244

   245

        # Get a copy list of default variables to map

   246

        variables = NODE_VARIABLES[:]

   247

   248

        # Set AxisRef public struct members value

   249

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

   250

        for param in node_params["children"]:

   251

            param_name = param["name"]

   252

   253

            # Param is optional variables section enable flag

   254

            extra_node_variable_infos = EXTRA_NODE_VARIABLES_DICT.get(param_name)

   255

            if extra_node_variable_infos is not None:

   256

   257

                if not param["value"]:

   258

                    continue

   259

   260

                # Optional variables section is enabled

   261

                for variable_infos in extra_node_variable_infos:

   262

                    var_name = variable_infos["description"][0]

   263

   264

                    # Add each variables defined in section description to the

   265

                    # list of variables to map

   266

                    variables.append(variable_infos["description"])

   267

   268

                    # Add code to publish or retrive variable

   269

                    for var_exchange_dir, str_list, default_template in [

   270

                         ("retrieve", extra_variables_retrieve,

   271

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

   272

                         ("publish", extra_variables_publish,

   273

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

   274

   275

                        template = variable_infos.get(var_exchange_dir, 

   276

                                                      default_template)

   277

                        if template is not None:

   278

                            extra_variables_publish.append(template % locals())

   279

   280

            # Set AxisRef public struct member value if defined

   281

            elif param["value"] is not None:

   282

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

   283

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

   284

                               else str(param["value"]))

   285

   286

                init_axis_params.append("""\

   287

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

   288

   289

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

   290

        # variables to add to network configuration

   291

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

   292

            var_size = self.GetSizeOfType(var_type)

   293

            var_name = """\

   294

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

   295

   296

            extern_located_variables_declaration.append(

   297

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

   298

            entry_variables.append(

   299

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

   300

            init_entry_variables.append(

   301

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

   302

   303

            self.CTNParent.FileGenerator.DeclareVariable(

   304

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

   305

   306

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

   307

        [fieldbus_interface_declaration, fieldbus_interface_definition,

   308

         init_axis_params, extra_variables_retrieve, extra_variables_publish,

   309

         extern_located_variables_declaration, entry_variables, 

   310

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

   311

            fieldbus_interface_declaration, fieldbus_interface_definition,

   312

            init_axis_params, extra_variables_retrieve, extra_variables_publish,

   313

            extern_located_variables_declaration, entry_variables, 

   314

            init_entry_variables])

   315

   316

        # Write generated content to CIA402 node file

   317

        Gen_CIA402Nodefile_path = os.path.join(buildpath, 

   318

                                "cia402node_%s.c"%location_str)

   319

        cia402nodefile = open(Gen_CIA402Nodefile_path, 'w')

   320

        cia402nodefile.write(plc_cia402node_code % locals())

   321

        cia402nodefile.close()

   322

   323

        return [(Gen_CIA402Nodefile_path, '"-I%s"'%os.path.abspath(self.GetCTRoot().GetIECLibPath()))],"",True