8

from plugger import PlugTemplate

    12

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

    13

#                 Ethercat DS402 Node

    14

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

    15

    16

NODE_VARIABLES = [

    17

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

    18

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

    19

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

    20

    ("ErrorCode", 0x603f, 0x00, "UINT", "I"),

    21

]

    22

    23

class _EthercatDS402SlavePlug:

    24

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

    25

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

    26

      <xsd:element name="EtherlabDS402Slave">

    27

        <xsd:complexType>

    28

          <xsd:attribute name="Node_Type" type="xsd:string" use="optional"/>

    29

        </xsd:complexType>

    30

      </xsd:element>

    31

    </xsd:schema>

    32

    """

    33

    34

    def _GetChildBySomething(self, something, toks):

    35

        return self

    36

    37

    def GetParamsAttributes(self, path = None):

    38

        infos = PlugTemplate.GetParamsAttributes(self, path = None)

    39

        for element in infos:

    40

            if element["name"] == "EtherlabDS402Slave":

    41

                for child in element["children"]:

    42

                    if child["name"] == "Node_Type":

    43

                        child["type"] = [module[0] for module in self.PlugParent.GetModulesByProfile(402)]

    44

        return infos

    45

    46

    def GetAllChannels(self):

    47

        AllChannels = PlugTemplate.GetAllChannels(self)

    48

        for slave_pos in self.PlugParent.GetSlaves():

    49

            if slave_pos[0] not in AllChannels:

    50

                AllChannels.append(slave_pos[0])

    51

        AllChannels.sort()

    52

        return AllChannels

    53

    54

    def GetCurrentLocation(self):

    55

        """

    56

        @return:  Tupple containing plugin IEC location of current plugin : %I0.0.4.5 => (0,0,4,5)

    57

        """

    58

        return self.PlugParent.GetCurrentLocation() + (self.BaseParams.getIEC_Channel(), 0)

    59

    60

    def GetSlaveInfos(self):

    61

        slave_type = self.EtherlabDS402Slave.getNode_Type()

    62

    63

        for module_type, vendor_id, product_code, revision_number in self.PlugParent.GetModulesByProfile(402):

    64

            if module_type == slave_type:

    65

                return {"device_type": module_type,

    66

                        "vendor": GenerateHexDecValue(vendor_id),

    67

                        "product_code": GenerateHexDecValue(product_code, 16),

    68

                        "revision_number": GenerateHexDecValue(revision_number, 16)}

    69

    70

        return None

    71

    72

    def GetVariableLocationTree(self):

    73

        slave_infos = self.GetSlaveInfos()

    74

        vars = []

    75

        if slave_infos is not None:

    76

            vars = self.PlugParent.GetDeviceLocationTree(self.GetCurrentLocation(), slave_infos) 

    77

    78

        return  {"name": self.BaseParams.getName(),

    79

                 "type": LOCATION_PLUGIN,

    80

                 "location": self.GetFullIEC_Channel(),

    81

                 "children": vars}

    82

    83

    def PlugGenerate_C(self, buildpath, locations):

    84

        """

    85

        Generate C code

    86

        @param current_location: Tupple containing plugin IEC location : %I0.0.4.5 => (0,0,4,5)

    87

        @param locations: List of complete variables locations \

    88

            [{"IEC_TYPE" : the IEC type (i.e. "INT", "STRING", ...)

    89

            "NAME" : name of the variable (generally "__IW0_1_2" style)

    90

            "DIR" : direction "Q","I" or "M"

    91

            "SIZE" : size "X", "B", "W", "D", "L"

    92

            "LOC" : tuple of interger for IEC location (0,1,2,...)

    93

            }, ...]

    94

        @return: [(C_file_name, CFLAGS),...] , LDFLAGS_TO_APPEND

    95

        """

    96

        current_location = self.GetCurrentLocation()

    97

    98

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

    99

   100

        slave_pos = current_location[-2:]

   101

   102

        slave_infos = self.GetSlaveInfos()

   103

        device = None

   104

        if slave_infos is not None:

   105

            device = self.PlugParent.GetModuleInfos(slave_infos)

   106

   107

        if device is None:

   108

            raise (ValueError, 

   109

                   _("No information found for DS402 node \"%s\" at location %s!") % (

   110

                      slave_infos["device_type"], ".".join(current_location)))

   111

   112

        slave_idx = self.PlugParent.FileGenerator.DeclareSlave(slave_pos, slave_infos)

   113

   114

        plc_ds402node_filepath = os.path.join(os.path.split(__file__)[0], "plc_ds402node.c")

   115

        plc_ds402node_file = open(plc_ds402node_filepath, 'r')

   116

        plc_ds402node_code = plc_ds402node_file.read()

   117

        plc_ds402node_file.close()

   118

   119

        str_completion = {

   120

            "location": location_str,

   121

            "MCL_includes": "",

   122

            "located_variables_declaration": [],

   123

            "entry_variables": [],

   124

            "extern_pdo_entry_configuration": [],

   125

            "retrieve_variables": [],

   126

            "publish_variables": [],

   127

        }

   128

   129

        variables = {}

   130

        for variable in NODE_VARIABLES:

   131

            var_infos = dict(zip(["name", "index", "subindex", "var_type", "dir"], variable))

   132

            var_infos["location"] = location_str

   133

            var_infos["slave"] = slave_idx

   134

            var_infos["var_size"] = self.PlugParent.GetSizeOfType(var_infos["var_type"])

   135

            var_infos["var_name"] = "__%(dir)s%(var_size)s%(location)s_%(index)d_%(subindex)d" % var_infos

   136

            var_infos["real_var"] = "__DS402Node_%(location)s.%(name)s" % var_infos

   137

            var_infos.update(slave_infos)

   138

   139

            variables[(var_infos["index"], var_infos["subindex"])] = var_infos["name"]

   140

   141

            str_completion["entry_variables"].append("    IEC_%(var_type)s %(name)s;" % var_infos)

   142

   143

            ConfigureVariable(var_infos, str_completion)

   144

   145

            str_completion["extern_pdo_entry_configuration"].append(

   146

                "extern unsigned int slave%(slave)d_%(index).4x_%(subindex).2x;" % var_infos)

   147

   148

            if var_infos["var_type"] == "BOOL":

   149

                str_completion["extern_pdo_entry_configuration"].append(

   150

                    "extern unsigned int slave%(slave)d_%(index).4x_%(subindex).2x_bit;" % var_infos)

   151

   152

            self.PlugParent.FileGenerator.DeclareVariable(

   153

                    slave_pos, var_infos["index"], var_infos["subindex"], 

   154

                    var_infos["var_type"], var_infos["dir"], var_infos["var_name"], False)

   155

   156

        for element in ["located_variables_declaration", 

   157

                        "entry_variables", 

   158

                        "extern_pdo_entry_configuration", 

   159

                        "retrieve_variables", 

   160

                        "publish_variables"]:

   161

            str_completion[element] = "\n".join(str_completion[element])

   162

   163

        Gen_DS402Nodefile_path = os.path.join(buildpath, "ds402node_%s.c"%location_str)

   164

        ds402nodefile = open(Gen_DS402Nodefile_path, 'w')

   165

        ds402nodefile.write(plc_ds402node_code % str_completion)

   166

        ds402nodefile.close()

   167

   168

        for location in locations:

   169

            loc = location["LOC"][len(current_location):]

   170

            if variables.get(loc, None) is None:

   171

                self.PlugParent.FileGenerator.DeclareVariable(

   172

                    slave_pos, loc[0], loc[1], location["IEC_TYPE"], location["DIR"], location["NAME"])

   173

   174

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

   175

   176

   177

   186

VARCLASSCONVERSION = {"T": LOCATION_VAR_INPUT, "R": LOCATION_VAR_OUTPUT, "RT": LOCATION_VAR_MEMORY}

   256

    PlugChildsTypes = [("EthercatDS402Slave", _EthercatDS402SlavePlug, "Ethercat DS402 Slave")]

   257

   300

        for PlugInstance in self.IterChilds():

   301

            slaves.append((PlugInstance.BaseParams.getIEC_Channel(), 0))

   302

        slaves.sort()

   326

        for PlugInstance in self.IterChilds():

   327

            if PlugInstance.BaseParams.getIEC_Channel() == alias:

   328

                return _("Slave with alias \"%d\" already exists!" % alias)

   375

    def GetModulesByProfile(self, profile_type):

   376

        return self.PlugParent.GetModulesByProfile(profile_type)

   377

   381

    def GetDeviceLocationTree(self, current_location, type_infos):

   382

        vars = []

   383

   384

        device = self.GetModuleInfos(type_infos)

   385

        if device is not None:

   386

            sync_managers = []

   387

            for sync_manager in device.getSm():

   388

                sync_manager_control_byte = ExtractHexDecValue(sync_manager.getControlByte())

   389

                sync_manager_direction = sync_manager_control_byte & 0x0c

   390

                if sync_manager_direction:

   391

                    sync_managers.append(LOCATION_VAR_OUTPUT)

   392

                else:

   393

                    sync_managers.append(LOCATION_VAR_INPUT)

   394

   395

            entries = device.GetEntriesList().items()

   396

            entries.sort()

   397

            for (index, subindex), entry in entries:

   398

                var_size = self.GetSizeOfType(entry["Type"])

   399

                if var_size is not None:

   400

                    var_class = VARCLASSCONVERSION.get(entry["PDOMapping"], None)

   401

                    if var_class is not None:

   402

                        if var_class == LOCATION_VAR_INPUT:

   403

                            var_dir = "%I"

   404

                        else:

   405

                            var_dir = "%Q"    

   406

   407

                        vars.append({"name": "0x%4.4x-0x%2.2x: %s" % (index, subindex, entry["Name"]),

   408

                                     "type": var_class,

   409

                                     "size": var_size,

   410

                                     "IEC_type": entry["Type"],

   411

                                     "var_name": "%s_%4.4x_%2.2x" % (type_infos["device_type"], index, subindex),

   412

                                     "location": "%s%s%s"%(var_dir, var_size, ".".join(map(str, current_location + 

   413

                                                                                                (index, subindex)))),

   414

                                     "description": "",

   415

                                     "children": []})

   416

   417

        return vars

   418

   431

                vars = self.GetDeviceLocationTree(current_location + slave_pos, type_infos)

   432

                if len(vars) > 0:

   468

    def _Generate_C(self, buildpath, locations):

   469

        current_location = self.GetCurrentLocation()

   470

        # define a unique name for the generated C file

   471

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

   472

   473

        Gen_Ethercatfile_path = os.path.join(buildpath, "ethercat_%s.c"%location_str)

   474

   475

        self.FileGenerator = _EthercatCFileGenerator(self)

   476

   477

        LocationCFilesAndCFLAGS, LDFLAGS, extra_files = PlugTemplate._Generate_C(self, buildpath, locations)

   478

   479

        self.FileGenerator.GenerateCFile(Gen_Ethercatfile_path, location_str, self.EtherlabNode)

   480

   481

        LocationCFilesAndCFLAGS.append(

   482

            (current_location, 

   483

             [(Gen_Ethercatfile_path, '"-I%s"'%os.path.abspath(self.GetPlugRoot().GetIECLibPath()))], 

   484

             True))

   485

        LDFLAGS.append("-lethercat -lrtdm")

   486

   487

        return LocationCFilesAndCFLAGS, LDFLAGS, extra_files

   488

   503

   504

        slaves = self.GetSlaves()

   505

        for slave_pos in slaves:

   506

            slave = self.GetSlave(slave_pos)

   507

            if slave is not None:

   508

                self.FileGenerator.DeclareSlave(slave_pos, slave.getType())