etherlab/etherlab.py
author laurent
Thu, 23 Feb 2012 15:48:19 +0100
changeset 2035 1d113faf4433
parent 2034 ae8fecf082a1
child 2037 d54036f70390
permissions -rw-r--r--
Fix bug with PowerFeedback value
2022
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
     1
import os, shutil
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
     2
import cPickle
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
     3
from xml.dom import minidom
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
     4
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
     5
import wx
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
     6
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
     7
from xmlclass import *
2032
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
     8
from plugger import PlugTemplate
2023
f9f884cf3033 Adding support for not configuring pdos when not mandatory and not needed by locations defined in PLC program. Adding support for displaying locations tree in Topology panel and BrowseLocationsDialog. Merging pdos grid and variables grid into one single grid in slave infos panel.
laurent
parents: 2022
diff changeset
     9
from PLCControler import UndoBuffer, LOCATION_PLUGIN, LOCATION_MODULE, LOCATION_GROUP, LOCATION_VAR_INPUT, LOCATION_VAR_OUTPUT, LOCATION_VAR_MEMORY
2034
ae8fecf082a1 Adding support for MCL
laurent
parents: 2032
diff changeset
    10
from ConfigEditor import ConfigEditor, DS402NodeEditor, ETHERCAT_VENDOR, ETHERCAT_GROUP, ETHERCAT_DEVICE
2022
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
    11
2032
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
    12
#--------------------------------------------------
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
    13
#                 Ethercat DS402 Node
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
    14
#--------------------------------------------------
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
    15
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
    16
NODE_VARIABLES = [
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
    17
    ("ControlWord", 0x6040, 0x00, "UINT", "Q"),
2034
ae8fecf082a1 Adding support for MCL
laurent
parents: 2032
diff changeset
    18
    ("TargetPosition", 0x607a, 0x00, "DINT", "Q"),
2032
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
    19
    ("StatusWord", 0x6041, 0x00, "UINT", "I"),
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
    20
    ("ModesOfOperationDisplay", 0x06061, 0x00, "SINT", "I"),
2034
ae8fecf082a1 Adding support for MCL
laurent
parents: 2032
diff changeset
    21
    ("ActualPosition", 0x6064, 0x00, "DINT", "I"),
2032
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
    22
    ("ErrorCode", 0x603f, 0x00, "UINT", "I"),
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
    23
]
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
    24
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
    25
class _EthercatDS402SlavePlug:
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
    26
    XSD = """<?xml version="1.0" encoding="ISO-8859-1" ?>
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
    27
    <xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema">
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
    28
      <xsd:element name="EtherlabDS402Slave">
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
    29
        <xsd:complexType>
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
    30
          <xsd:attribute name="Node_Type" type="xsd:string" use="optional"/>
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
    31
        </xsd:complexType>
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
    32
      </xsd:element>
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
    33
    </xsd:schema>
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
    34
    """
2034
ae8fecf082a1 Adding support for MCL
laurent
parents: 2032
diff changeset
    35
    EditorType = DS402NodeEditor
ae8fecf082a1 Adding support for MCL
laurent
parents: 2032
diff changeset
    36
    
ae8fecf082a1 Adding support for MCL
laurent
parents: 2032
diff changeset
    37
    def ExtractHexDecValue(self, value):
ae8fecf082a1 Adding support for MCL
laurent
parents: 2032
diff changeset
    38
        return ExtractHexDecValue(value)
ae8fecf082a1 Adding support for MCL
laurent
parents: 2032
diff changeset
    39
ae8fecf082a1 Adding support for MCL
laurent
parents: 2032
diff changeset
    40
    def GetSizeOfType(self, type):
ae8fecf082a1 Adding support for MCL
laurent
parents: 2032
diff changeset
    41
        return TYPECONVERSION.get(self.GetPlugRoot().GetBaseType(type), None)
2032
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
    42
    
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
    43
    def _GetChildBySomething(self, something, toks):
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
    44
        return self
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
    45
    
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
    46
    def GetParamsAttributes(self, path = None):
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
    47
        infos = PlugTemplate.GetParamsAttributes(self, path = None)
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
    48
        for element in infos:
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
    49
            if element["name"] == "EtherlabDS402Slave":
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
    50
                for child in element["children"]:
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
    51
                    if child["name"] == "Node_Type":
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
    52
                        child["type"] = [module[0] for module in self.PlugParent.GetModulesByProfile(402)]
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
    53
        return infos
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
    54
    
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
    55
    def GetAllChannels(self):
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
    56
        AllChannels = PlugTemplate.GetAllChannels(self)
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
    57
        for slave_pos in self.PlugParent.GetSlaves():
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
    58
            if slave_pos[0] not in AllChannels:
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
    59
                AllChannels.append(slave_pos[0])
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
    60
        AllChannels.sort()
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
    61
        return AllChannels
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
    62
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
    63
    def GetCurrentLocation(self):
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
    64
        """
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
    65
        @return:  Tupple containing plugin IEC location of current plugin : %I0.0.4.5 => (0,0,4,5)
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
    66
        """
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
    67
        return self.PlugParent.GetCurrentLocation() + (self.BaseParams.getIEC_Channel(), 0)
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
    68
2034
ae8fecf082a1 Adding support for MCL
laurent
parents: 2032
diff changeset
    69
    def GetSlaveTypeInfos(self):
2032
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
    70
        slave_type = self.EtherlabDS402Slave.getNode_Type()
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
    71
        
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
    72
        for module_type, vendor_id, product_code, revision_number in self.PlugParent.GetModulesByProfile(402):
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
    73
            if module_type == slave_type:
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
    74
                return {"device_type": module_type,
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
    75
                        "vendor": GenerateHexDecValue(vendor_id),
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
    76
                        "product_code": GenerateHexDecValue(product_code, 16),
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
    77
                        "revision_number": GenerateHexDecValue(revision_number, 16)}
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
    78
        
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
    79
        return None
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
    80
2034
ae8fecf082a1 Adding support for MCL
laurent
parents: 2032
diff changeset
    81
    def GetSlaveInfos(self):
ae8fecf082a1 Adding support for MCL
laurent
parents: 2032
diff changeset
    82
        slave_typeinfos = self.GetSlaveTypeInfos()
ae8fecf082a1 Adding support for MCL
laurent
parents: 2032
diff changeset
    83
        if slave_typeinfos is not None:
ae8fecf082a1 Adding support for MCL
laurent
parents: 2032
diff changeset
    84
            device = self.PlugParent.GetModuleInfos(slave_typeinfos)
ae8fecf082a1 Adding support for MCL
laurent
parents: 2032
diff changeset
    85
            if device is not None:
ae8fecf082a1 Adding support for MCL
laurent
parents: 2032
diff changeset
    86
                infos = slave_typeinfos.copy()
ae8fecf082a1 Adding support for MCL
laurent
parents: 2032
diff changeset
    87
                entries = device.GetEntriesList()
ae8fecf082a1 Adding support for MCL
laurent
parents: 2032
diff changeset
    88
                entries_list = entries.items()
ae8fecf082a1 Adding support for MCL
laurent
parents: 2032
diff changeset
    89
                entries_list.sort()
ae8fecf082a1 Adding support for MCL
laurent
parents: 2032
diff changeset
    90
                infos.update({"physics": device.getPhysics(),
ae8fecf082a1 Adding support for MCL
laurent
parents: 2032
diff changeset
    91
                              "sync_managers": device.GetSyncManagers(),
ae8fecf082a1 Adding support for MCL
laurent
parents: 2032
diff changeset
    92
                              "entries": [entry[1] for entry in entries_list]})
ae8fecf082a1 Adding support for MCL
laurent
parents: 2032
diff changeset
    93
                return infos
ae8fecf082a1 Adding support for MCL
laurent
parents: 2032
diff changeset
    94
        return None
ae8fecf082a1 Adding support for MCL
laurent
parents: 2032
diff changeset
    95
2032
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
    96
    def GetVariableLocationTree(self):
2034
ae8fecf082a1 Adding support for MCL
laurent
parents: 2032
diff changeset
    97
        slave_typeinfos = self.GetSlaveTypeInfos()
2032
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
    98
        vars = []
2034
ae8fecf082a1 Adding support for MCL
laurent
parents: 2032
diff changeset
    99
        if slave_typeinfos is not None:
ae8fecf082a1 Adding support for MCL
laurent
parents: 2032
diff changeset
   100
            vars = self.PlugParent.GetDeviceLocationTree(self.GetCurrentLocation(), slave_typeinfos) 
2032
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   101
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   102
        return  {"name": self.BaseParams.getName(),
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   103
                 "type": LOCATION_PLUGIN,
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   104
                 "location": self.GetFullIEC_Channel(),
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   105
                 "children": vars}
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   106
2034
ae8fecf082a1 Adding support for MCL
laurent
parents: 2032
diff changeset
   107
    PluginMethods = [
ae8fecf082a1 Adding support for MCL
laurent
parents: 2032
diff changeset
   108
        {"bitmap" : os.path.join("images", "EditCfile"),
ae8fecf082a1 Adding support for MCL
laurent
parents: 2032
diff changeset
   109
         "name" : _("Edit Node"), 
ae8fecf082a1 Adding support for MCL
laurent
parents: 2032
diff changeset
   110
         "tooltip" : _("Edit Node"),
ae8fecf082a1 Adding support for MCL
laurent
parents: 2032
diff changeset
   111
         "method" : "_OpenView"},
ae8fecf082a1 Adding support for MCL
laurent
parents: 2032
diff changeset
   112
    ]
ae8fecf082a1 Adding support for MCL
laurent
parents: 2032
diff changeset
   113
ae8fecf082a1 Adding support for MCL
laurent
parents: 2032
diff changeset
   114
2032
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   115
    def PlugGenerate_C(self, buildpath, locations):
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   116
        """
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   117
        Generate C code
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   118
        @param current_location: Tupple containing plugin IEC location : %I0.0.4.5 => (0,0,4,5)
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   119
        @param locations: List of complete variables locations \
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   120
            [{"IEC_TYPE" : the IEC type (i.e. "INT", "STRING", ...)
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   121
            "NAME" : name of the variable (generally "__IW0_1_2" style)
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   122
            "DIR" : direction "Q","I" or "M"
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   123
            "SIZE" : size "X", "B", "W", "D", "L"
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   124
            "LOC" : tuple of interger for IEC location (0,1,2,...)
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   125
            }, ...]
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   126
        @return: [(C_file_name, CFLAGS),...] , LDFLAGS_TO_APPEND
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   127
        """
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   128
        current_location = self.GetCurrentLocation()
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   129
        
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   130
        location_str = "_".join(map(lambda x:str(x), current_location))
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   131
        
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   132
        slave_pos = current_location[-2:]
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   133
        
2034
ae8fecf082a1 Adding support for MCL
laurent
parents: 2032
diff changeset
   134
        slave_typeinfos = self.GetSlaveTypeInfos()
2032
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   135
        device = None
2034
ae8fecf082a1 Adding support for MCL
laurent
parents: 2032
diff changeset
   136
        if slave_typeinfos is not None:
ae8fecf082a1 Adding support for MCL
laurent
parents: 2032
diff changeset
   137
            device = self.PlugParent.GetModuleInfos(slave_typeinfos)
2032
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   138
        
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   139
        if device is None:
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   140
            raise (ValueError, 
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   141
                   _("No information found for DS402 node \"%s\" at location %s!") % (
2034
ae8fecf082a1 Adding support for MCL
laurent
parents: 2032
diff changeset
   142
                      slave_typeinfos["device_type"], ".".join(current_location)))
2032
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   143
            
2034
ae8fecf082a1 Adding support for MCL
laurent
parents: 2032
diff changeset
   144
        self.PlugParent.FileGenerator.DeclareSlave(slave_pos, slave_typeinfos)
2032
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   145
        
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   146
        plc_ds402node_filepath = os.path.join(os.path.split(__file__)[0], "plc_ds402node.c")
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   147
        plc_ds402node_file = open(plc_ds402node_filepath, 'r')
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   148
        plc_ds402node_code = plc_ds402node_file.read()
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   149
        plc_ds402node_file.close()
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   150
        
2034
ae8fecf082a1 Adding support for MCL
laurent
parents: 2032
diff changeset
   151
        from plugins.motion import Headers
ae8fecf082a1 Adding support for MCL
laurent
parents: 2032
diff changeset
   152
        
2032
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   153
        str_completion = {
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   154
            "location": location_str,
2034
ae8fecf082a1 Adding support for MCL
laurent
parents: 2032
diff changeset
   155
            "MCL_headers": Headers,
ae8fecf082a1 Adding support for MCL
laurent
parents: 2032
diff changeset
   156
            "extern_located_variables_declaration": [],
2032
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   157
            "entry_variables": [],
2034
ae8fecf082a1 Adding support for MCL
laurent
parents: 2032
diff changeset
   158
            "init_entry_variables": [],
2032
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   159
        }
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   160
        
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   161
        for variable in NODE_VARIABLES:
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   162
            var_infos = dict(zip(["name", "index", "subindex", "var_type", "dir"], variable))
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   163
            var_infos["location"] = location_str
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   164
            var_infos["var_size"] = self.PlugParent.GetSizeOfType(var_infos["var_type"])
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   165
            var_infos["var_name"] = "__%(dir)s%(var_size)s%(location)s_%(index)d_%(subindex)d" % var_infos
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   166
            
2034
ae8fecf082a1 Adding support for MCL
laurent
parents: 2032
diff changeset
   167
            str_completion["extern_located_variables_declaration"].append(
ae8fecf082a1 Adding support for MCL
laurent
parents: 2032
diff changeset
   168
                    "IEC_%(var_type)s *%(var_name)s;" % var_infos)
ae8fecf082a1 Adding support for MCL
laurent
parents: 2032
diff changeset
   169
            str_completion["entry_variables"].append(
ae8fecf082a1 Adding support for MCL
laurent
parents: 2032
diff changeset
   170
                    "    IEC_%(var_type)s *%(name)s;" % var_infos)
ae8fecf082a1 Adding support for MCL
laurent
parents: 2032
diff changeset
   171
            str_completion["init_entry_variables"].append(
ae8fecf082a1 Adding support for MCL
laurent
parents: 2032
diff changeset
   172
                    "    __DS402Node_%(location)s.%(name)s = %(var_name)s;" % var_infos)
2032
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   173
            
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   174
            self.PlugParent.FileGenerator.DeclareVariable(
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   175
                    slave_pos, var_infos["index"], var_infos["subindex"], 
2034
ae8fecf082a1 Adding support for MCL
laurent
parents: 2032
diff changeset
   176
                    var_infos["var_type"], var_infos["dir"], var_infos["var_name"])
ae8fecf082a1 Adding support for MCL
laurent
parents: 2032
diff changeset
   177
        
ae8fecf082a1 Adding support for MCL
laurent
parents: 2032
diff changeset
   178
        for element in ["extern_located_variables_declaration", 
2032
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   179
                        "entry_variables", 
2034
ae8fecf082a1 Adding support for MCL
laurent
parents: 2032
diff changeset
   180
                        "init_entry_variables"]:
2032
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   181
            str_completion[element] = "\n".join(str_completion[element])
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   182
        
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   183
        Gen_DS402Nodefile_path = os.path.join(buildpath, "ds402node_%s.c"%location_str)
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   184
        ds402nodefile = open(Gen_DS402Nodefile_path, 'w')
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   185
        ds402nodefile.write(plc_ds402node_code % str_completion)
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   186
        ds402nodefile.close()
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   187
        
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   188
        return [(Gen_DS402Nodefile_path, '"-I%s"'%os.path.abspath(self.GetPlugRoot().GetIECLibPath()))],"",True
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   189
        
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   190
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   191
2022
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   192
TYPECONVERSION = {"BOOL" : "X", "SINT" : "B", "INT" : "W", "DINT" : "D", "LINT" : "L",
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   193
    "USINT" : "B", "UINT" : "W", "UDINT" : "D", "ULINT" : "L", 
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   194
    "BYTE" : "B", "WORD" : "W", "DWORD" : "D", "LWORD" : "L"}
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   195
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   196
DATATYPECONVERSION = {"BOOL" : "BIT", "SINT" : "S8", "INT" : "S16", "DINT" : "S32", "LINT" : "S64",
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   197
    "USINT" : "U8", "UINT" : "U16", "UDINT" : "U32", "ULINT" : "U64", 
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   198
    "BYTE" : "U8", "WORD" : "U16", "DWORD" : "U32", "LWORD" : "U64"}
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   199
2032
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   200
VARCLASSCONVERSION = {"T": LOCATION_VAR_INPUT, "R": LOCATION_VAR_OUTPUT, "RT": LOCATION_VAR_MEMORY}
2029
7c848efa21c6 Adding support for displaying slave sync managers and profile object dictionary and for arbitrarily mapping variable through variable location
laurent
parents: 2026
diff changeset
   201
2022
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   202
#--------------------------------------------------
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   203
#                 Ethercat MASTER
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   204
#--------------------------------------------------
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   205
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   206
EtherCATConfigClasses = GenerateClassesFromXSD(os.path.join(os.path.dirname(__file__), "EtherCATConfig.xsd")) 
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   207
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   208
def ExtractHexDecValue(value):
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   209
    try:
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   210
        return int(value)
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   211
    except:
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   212
        pass
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   213
    try:
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   214
        return int(value.replace("#", "0"), 16)
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   215
    except:
2029
7c848efa21c6 Adding support for displaying slave sync managers and profile object dictionary and for arbitrarily mapping variable through variable location
laurent
parents: 2026
diff changeset
   216
        raise ValueError, "Invalid value for HexDecValue \"%s\"" % value
2022
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   217
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   218
def GenerateHexDecValue(value, base=10):
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   219
    if base == 10:
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   220
        return str(value)
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   221
    elif base == 16:
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   222
        return "#x%.8x" % value
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   223
    else:
2029
7c848efa21c6 Adding support for displaying slave sync managers and profile object dictionary and for arbitrarily mapping variable through variable location
laurent
parents: 2026
diff changeset
   224
        raise ValueError, "Not supported base"
2022
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   225
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   226
cls = EtherCATConfigClasses.get("Config_Slave", None)
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   227
if cls:
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   228
    
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   229
    def getType(self):
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   230
        slave_info = self.getInfo()
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   231
        return {"device_type": slave_info.getName(),
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   232
                "vendor": GenerateHexDecValue(slave_info.getVendorId()),
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   233
                "product_code": GenerateHexDecValue(slave_info.getProductCode(), 16),
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   234
                "revision_number": GenerateHexDecValue(slave_info.getRevisionNo(), 16)}
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   235
    setattr(cls, "getType", getType)
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   236
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   237
    def setType(self, type_infos):
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   238
        slave_info = self.getInfo()
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   239
        slave_info.setName(type_infos["device_type"])
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   240
        slave_info.setVendorId(ExtractHexDecValue(type_infos["vendor"]))
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   241
        slave_info.setProductCode(ExtractHexDecValue(type_infos["product_code"]))
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   242
        slave_info.setRevisionNo(ExtractHexDecValue(type_infos["revision_number"]))
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   243
    setattr(cls, "setType", setType)
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   244
    
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   245
cls = EtherCATConfigClasses.get("Slave_Info", None)
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   246
if cls:
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   247
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   248
    def getSlavePosition(self):
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   249
        return self.getPhysAddr(), self.getAutoIncAddr()
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   250
    setattr(cls, "getSlavePosition", getSlavePosition)
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   251
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   252
    def setSlavePosition(self, alias, pos):
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   253
        self.setPhysAddr(alias)
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   254
        self.setAutoIncAddr(pos)
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   255
    setattr(cls, "setSlavePosition", setSlavePosition)
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   256
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   257
class _EthercatPlug:
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   258
    XSD = """<?xml version="1.0" encoding="ISO-8859-1" ?>
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   259
    <xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema">
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   260
      <xsd:element name="EtherlabNode">
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   261
        <xsd:complexType>
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   262
          <xsd:attribute name="MasterNumber" type="xsd:integer" use="optional" default="0"/>
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   263
          <xsd:attribute name="ConfigurePDOs" type="xsd:boolean" use="optional" default="true"/>
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   264
        </xsd:complexType>
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   265
      </xsd:element>
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   266
    </xsd:schema>
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   267
    """
2023
f9f884cf3033 Adding support for not configuring pdos when not mandatory and not needed by locations defined in PLC program. Adding support for displaying locations tree in Topology panel and BrowseLocationsDialog. Merging pdos grid and variables grid into one single grid in slave infos panel.
laurent
parents: 2022
diff changeset
   268
    EditorType = ConfigEditor
2022
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   269
    
2032
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   270
    PlugChildsTypes = [("EthercatDS402Slave", _EthercatDS402SlavePlug, "Ethercat DS402 Slave")]
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   271
    
2022
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   272
    def __init__(self):
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   273
        filepath = self.ConfigFileName()
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   274
        
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   275
        self.Config = EtherCATConfigClasses["EtherCATConfig"]()
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   276
        if os.path.isfile(filepath):
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   277
            xmlfile = open(filepath, 'r')
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   278
            tree = minidom.parse(xmlfile)
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   279
            xmlfile.close()
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   280
            
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   281
            for child in tree.childNodes:
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   282
                if child.nodeType == tree.ELEMENT_NODE and child.nodeName == "EtherCATConfig":
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   283
                    self.Config.loadXMLTree(child, ["xmlns:xsi", "xsi:noNamespaceSchemaLocation"])
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   284
                    self.CreateConfigBuffer(True)
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   285
        else:
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   286
            self.CreateConfigBuffer(False)
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   287
            self.OnPlugSave()
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   288
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   289
    def ExtractHexDecValue(self, value):
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   290
        return ExtractHexDecValue(value)
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   291
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   292
    def GetSizeOfType(self, type):
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   293
        return TYPECONVERSION.get(self.GetPlugRoot().GetBaseType(type), None)
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   294
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   295
    def ConfigFileName(self):
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   296
        return os.path.join(self.PlugPath(), "config.xml")
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   297
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   298
    def GetSlaves(self):
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   299
        slaves = []
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   300
        for slave in self.Config.getConfig().getSlave():
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   301
            slaves.append(slave.getInfo().getSlavePosition())
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   302
        slaves.sort()
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   303
        return slaves
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   304
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   305
    def GetSlave(self, slave_pos):
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   306
        for slave in self.Config.getConfig().getSlave():
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   307
            slave_info = slave.getInfo()
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   308
            if slave_info.getSlavePosition() == slave_pos:
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   309
                return slave
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   310
        return None
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   311
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   312
    def AddSlave(self):
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   313
        slaves = self.GetSlaves()
2032
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   314
        for PlugInstance in self.IterChilds():
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   315
            slaves.append((PlugInstance.BaseParams.getIEC_Channel(), 0))
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   316
        slaves.sort()
2022
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   317
        if len(slaves) > 0:
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   318
            new_pos = (slaves[-1][0] + 1, 0)
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   319
        else:
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   320
            new_pos = (0, 0)
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   321
        slave = EtherCATConfigClasses["Config_Slave"]()
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   322
        slave_infos = slave.getInfo()
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   323
        slave_infos.setName("undefined")
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   324
        slave_infos.setSlavePosition(new_pos[0], new_pos[1])
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   325
        self.Config.getConfig().appendSlave(slave)
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   326
        self.BufferConfig()
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   327
        return new_pos
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   328
    
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   329
    def RemoveSlave(self, slave_pos):
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   330
        config = self.Config.getConfig()
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   331
        for idx, slave in enumerate(config.getSlave()):
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   332
            slave_infos = slave.getInfo()
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   333
            if slave_infos.getSlavePosition() == slave_pos:
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   334
                config.removeSlave(idx)
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   335
                self.BufferConfig()
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   336
                return True
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   337
        return False
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   338
    
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   339
    def SetSlavePos(self, slave_pos, alias=None, position=None):
2032
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   340
        for PlugInstance in self.IterChilds():
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   341
            if PlugInstance.BaseParams.getIEC_Channel() == alias:
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   342
                return _("Slave with alias \"%d\" already exists!" % alias)
2022
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   343
        slave = self.GetSlave(slave_pos)
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   344
        if slave is not None:
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   345
            slave_info = slave.getInfo()
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   346
            new_pos = slave_pos
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   347
            if alias is not None:
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   348
                new_pos = (alias, new_pos[1])
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   349
            if position is not None:
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   350
                new_pos = (new_pos[0], position)
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   351
            if self.GetSlave(new_pos) is not None:
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   352
                return _("Slave with position \"%d:%d\" already exists!" % new_pos)
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   353
            slave_info.setSlavePosition(*new_pos)
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   354
            self.BufferConfig()
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   355
        return None
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   356
    
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   357
    def GetSlaveType(self, slave_pos):
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   358
        slave = self.GetSlave(slave_pos)
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   359
        if slave is not None:
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   360
            return slave.getType()
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   361
        return None
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   362
    
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   363
    def SetSlaveType(self, slave_pos, type_infos):
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   364
        slave = self.GetSlave(slave_pos)
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   365
        if slave is not None:
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   366
            slave.setType(type_infos)
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   367
            self.BufferConfig()
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   368
        return None
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   369
    
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   370
    def GetSlaveInfos(self, slave_pos):
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   371
        slave = self.GetSlave(slave_pos)
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   372
        if slave is not None:
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   373
            type_infos = slave.getType()
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   374
            device = self.GetModuleInfos(type_infos)
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   375
            if device is not None:
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   376
                infos = type_infos.copy()
2029
7c848efa21c6 Adding support for displaying slave sync managers and profile object dictionary and for arbitrarily mapping variable through variable location
laurent
parents: 2026
diff changeset
   377
                entries = device.GetEntriesList()
7c848efa21c6 Adding support for displaying slave sync managers and profile object dictionary and for arbitrarily mapping variable through variable location
laurent
parents: 2026
diff changeset
   378
                entries_list = entries.items()
7c848efa21c6 Adding support for displaying slave sync managers and profile object dictionary and for arbitrarily mapping variable through variable location
laurent
parents: 2026
diff changeset
   379
                entries_list.sort()
2022
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   380
                infos.update({"physics": device.getPhysics(),
2029
7c848efa21c6 Adding support for displaying slave sync managers and profile object dictionary and for arbitrarily mapping variable through variable location
laurent
parents: 2026
diff changeset
   381
                              "sync_managers": device.GetSyncManagers(),
7c848efa21c6 Adding support for displaying slave sync managers and profile object dictionary and for arbitrarily mapping variable through variable location
laurent
parents: 2026
diff changeset
   382
                              "entries": [entry[1] for entry in entries_list]})
2022
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   383
                return infos
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   384
        return None
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   385
    
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   386
    def GetModuleInfos(self, type_infos):
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   387
        return self.PlugParent.GetModuleInfos(type_infos)
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   388
    
2032
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   389
    def GetModulesByProfile(self, profile_type):
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   390
        return self.PlugParent.GetModulesByProfile(profile_type)
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   391
    
2022
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   392
    def GetSlaveTypesLibrary(self):
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   393
        return self.PlugParent.GetModulesLibrary()
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   394
    
2032
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   395
    def GetDeviceLocationTree(self, current_location, type_infos):
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   396
        vars = []
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   397
        
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   398
        device = self.GetModuleInfos(type_infos)
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   399
        if device is not None:
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   400
            sync_managers = []
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   401
            for sync_manager in device.getSm():
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   402
                sync_manager_control_byte = ExtractHexDecValue(sync_manager.getControlByte())
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   403
                sync_manager_direction = sync_manager_control_byte & 0x0c
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   404
                if sync_manager_direction:
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   405
                    sync_managers.append(LOCATION_VAR_OUTPUT)
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   406
                else:
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   407
                    sync_managers.append(LOCATION_VAR_INPUT)
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   408
            
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   409
            entries = device.GetEntriesList().items()
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   410
            entries.sort()
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   411
            for (index, subindex), entry in entries:
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   412
                var_size = self.GetSizeOfType(entry["Type"])
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   413
                if var_size is not None:
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   414
                    var_class = VARCLASSCONVERSION.get(entry["PDOMapping"], None)
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   415
                    if var_class is not None:
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   416
                        if var_class == LOCATION_VAR_INPUT:
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   417
                            var_dir = "%I"
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   418
                        else:
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   419
                            var_dir = "%Q"    
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   420
                    
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   421
                        vars.append({"name": "0x%4.4x-0x%2.2x: %s" % (index, subindex, entry["Name"]),
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   422
                                     "type": var_class,
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   423
                                     "size": var_size,
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   424
                                     "IEC_type": entry["Type"],
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   425
                                     "var_name": "%s_%4.4x_%2.2x" % (type_infos["device_type"], index, subindex),
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   426
                                     "location": "%s%s%s"%(var_dir, var_size, ".".join(map(str, current_location + 
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   427
                                                                                                (index, subindex)))),
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   428
                                     "description": "",
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   429
                                     "children": []})
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   430
        
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   431
        return vars
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   432
    
2023
f9f884cf3033 Adding support for not configuring pdos when not mandatory and not needed by locations defined in PLC program. Adding support for displaying locations tree in Topology panel and BrowseLocationsDialog. Merging pdos grid and variables grid into one single grid in slave infos panel.
laurent
parents: 2022
diff changeset
   433
    def GetVariableLocationTree(self):
f9f884cf3033 Adding support for not configuring pdos when not mandatory and not needed by locations defined in PLC program. Adding support for displaying locations tree in Topology panel and BrowseLocationsDialog. Merging pdos grid and variables grid into one single grid in slave infos panel.
laurent
parents: 2022
diff changeset
   434
        '''See PlugTemplate.GetVariableLocationTree() for a description.'''
f9f884cf3033 Adding support for not configuring pdos when not mandatory and not needed by locations defined in PLC program. Adding support for displaying locations tree in Topology panel and BrowseLocationsDialog. Merging pdos grid and variables grid into one single grid in slave infos panel.
laurent
parents: 2022
diff changeset
   435
f9f884cf3033 Adding support for not configuring pdos when not mandatory and not needed by locations defined in PLC program. Adding support for displaying locations tree in Topology panel and BrowseLocationsDialog. Merging pdos grid and variables grid into one single grid in slave infos panel.
laurent
parents: 2022
diff changeset
   436
        current_location = self.GetCurrentLocation()
f9f884cf3033 Adding support for not configuring pdos when not mandatory and not needed by locations defined in PLC program. Adding support for displaying locations tree in Topology panel and BrowseLocationsDialog. Merging pdos grid and variables grid into one single grid in slave infos panel.
laurent
parents: 2022
diff changeset
   437
        
f9f884cf3033 Adding support for not configuring pdos when not mandatory and not needed by locations defined in PLC program. Adding support for displaying locations tree in Topology panel and BrowseLocationsDialog. Merging pdos grid and variables grid into one single grid in slave infos panel.
laurent
parents: 2022
diff changeset
   438
        groups = []
f9f884cf3033 Adding support for not configuring pdos when not mandatory and not needed by locations defined in PLC program. Adding support for displaying locations tree in Topology panel and BrowseLocationsDialog. Merging pdos grid and variables grid into one single grid in slave infos panel.
laurent
parents: 2022
diff changeset
   439
        for slave_pos in self.GetSlaves():
f9f884cf3033 Adding support for not configuring pdos when not mandatory and not needed by locations defined in PLC program. Adding support for displaying locations tree in Topology panel and BrowseLocationsDialog. Merging pdos grid and variables grid into one single grid in slave infos panel.
laurent
parents: 2022
diff changeset
   440
            
f9f884cf3033 Adding support for not configuring pdos when not mandatory and not needed by locations defined in PLC program. Adding support for displaying locations tree in Topology panel and BrowseLocationsDialog. Merging pdos grid and variables grid into one single grid in slave infos panel.
laurent
parents: 2022
diff changeset
   441
            slave = self.GetSlave(slave_pos)
f9f884cf3033 Adding support for not configuring pdos when not mandatory and not needed by locations defined in PLC program. Adding support for displaying locations tree in Topology panel and BrowseLocationsDialog. Merging pdos grid and variables grid into one single grid in slave infos panel.
laurent
parents: 2022
diff changeset
   442
            if slave is not None:
f9f884cf3033 Adding support for not configuring pdos when not mandatory and not needed by locations defined in PLC program. Adding support for displaying locations tree in Topology panel and BrowseLocationsDialog. Merging pdos grid and variables grid into one single grid in slave infos panel.
laurent
parents: 2022
diff changeset
   443
                type_infos = slave.getType()
2022
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   444
                
2032
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   445
                vars = self.GetDeviceLocationTree(current_location + slave_pos, type_infos)
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   446
                if len(vars) > 0:
2023
f9f884cf3033 Adding support for not configuring pdos when not mandatory and not needed by locations defined in PLC program. Adding support for displaying locations tree in Topology panel and BrowseLocationsDialog. Merging pdos grid and variables grid into one single grid in slave infos panel.
laurent
parents: 2022
diff changeset
   447
                    groups.append({"name": "%s (%d,%d)" % ((type_infos["device_type"],) + slave_pos),
f9f884cf3033 Adding support for not configuring pdos when not mandatory and not needed by locations defined in PLC program. Adding support for displaying locations tree in Topology panel and BrowseLocationsDialog. Merging pdos grid and variables grid into one single grid in slave infos panel.
laurent
parents: 2022
diff changeset
   448
                                   "type": LOCATION_GROUP,
f9f884cf3033 Adding support for not configuring pdos when not mandatory and not needed by locations defined in PLC program. Adding support for displaying locations tree in Topology panel and BrowseLocationsDialog. Merging pdos grid and variables grid into one single grid in slave infos panel.
laurent
parents: 2022
diff changeset
   449
                                   "location": ".".join(map(str, current_location + slave_pos)) + ".x",
f9f884cf3033 Adding support for not configuring pdos when not mandatory and not needed by locations defined in PLC program. Adding support for displaying locations tree in Topology panel and BrowseLocationsDialog. Merging pdos grid and variables grid into one single grid in slave infos panel.
laurent
parents: 2022
diff changeset
   450
                                   "children": vars})
f9f884cf3033 Adding support for not configuring pdos when not mandatory and not needed by locations defined in PLC program. Adding support for displaying locations tree in Topology panel and BrowseLocationsDialog. Merging pdos grid and variables grid into one single grid in slave infos panel.
laurent
parents: 2022
diff changeset
   451
                
f9f884cf3033 Adding support for not configuring pdos when not mandatory and not needed by locations defined in PLC program. Adding support for displaying locations tree in Topology panel and BrowseLocationsDialog. Merging pdos grid and variables grid into one single grid in slave infos panel.
laurent
parents: 2022
diff changeset
   452
        return  {"name": self.BaseParams.getName(),
f9f884cf3033 Adding support for not configuring pdos when not mandatory and not needed by locations defined in PLC program. Adding support for displaying locations tree in Topology panel and BrowseLocationsDialog. Merging pdos grid and variables grid into one single grid in slave infos panel.
laurent
parents: 2022
diff changeset
   453
                 "type": LOCATION_PLUGIN,
f9f884cf3033 Adding support for not configuring pdos when not mandatory and not needed by locations defined in PLC program. Adding support for displaying locations tree in Topology panel and BrowseLocationsDialog. Merging pdos grid and variables grid into one single grid in slave infos panel.
laurent
parents: 2022
diff changeset
   454
                 "location": self.GetFullIEC_Channel(),
f9f884cf3033 Adding support for not configuring pdos when not mandatory and not needed by locations defined in PLC program. Adding support for displaying locations tree in Topology panel and BrowseLocationsDialog. Merging pdos grid and variables grid into one single grid in slave infos panel.
laurent
parents: 2022
diff changeset
   455
                 "children": groups}
f9f884cf3033 Adding support for not configuring pdos when not mandatory and not needed by locations defined in PLC program. Adding support for displaying locations tree in Topology panel and BrowseLocationsDialog. Merging pdos grid and variables grid into one single grid in slave infos panel.
laurent
parents: 2022
diff changeset
   456
    
2022
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   457
    PluginMethods = [
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   458
        {"bitmap" : os.path.join("images", "EditCfile"),
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   459
         "name" : _("Edit Config"), 
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   460
         "tooltip" : _("Edit Config"),
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   461
         "method" : "_OpenView"},
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   462
    ]
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   463
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   464
    def PlugTestModified(self):
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   465
        return self.ChangesToSave or not self.ConfigIsSaved()    
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   466
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   467
    def OnPlugSave(self):
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   468
        filepath = self.ConfigFileName()
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   469
        
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   470
        text = "<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"no\"?>\n"
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   471
        extras = {"xmlns:xsi":"http://www.w3.org/2001/XMLSchema-instance",
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   472
                  "xsi:noNamespaceSchemaLocation" : "EtherCATInfo.xsd"}
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   473
        text += self.Config.generateXMLText("EtherCATConfig", 0, extras)
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   474
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   475
        xmlfile = open(filepath,"w")
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   476
        xmlfile.write(text.encode("utf-8"))
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   477
        xmlfile.close()
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   478
        
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   479
        self.ConfigBuffer.CurrentSaved()
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   480
        return True
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   481
2032
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   482
    def _Generate_C(self, buildpath, locations):
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   483
        current_location = self.GetCurrentLocation()
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   484
        # define a unique name for the generated C file
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   485
        location_str = "_".join(map(lambda x:str(x), current_location))
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   486
        
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   487
        Gen_Ethercatfile_path = os.path.join(buildpath, "ethercat_%s.c"%location_str)
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   488
        
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   489
        self.FileGenerator = _EthercatCFileGenerator(self)
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   490
        
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   491
        LocationCFilesAndCFLAGS, LDFLAGS, extra_files = PlugTemplate._Generate_C(self, buildpath, locations)
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   492
        
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   493
        self.FileGenerator.GenerateCFile(Gen_Ethercatfile_path, location_str, self.EtherlabNode)
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   494
        
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   495
        LocationCFilesAndCFLAGS.append(
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   496
            (current_location, 
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   497
             [(Gen_Ethercatfile_path, '"-I%s"'%os.path.abspath(self.GetPlugRoot().GetIECLibPath()))], 
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   498
             True))
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   499
        LDFLAGS.append("-lethercat -lrtdm")
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   500
        
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   501
        return LocationCFilesAndCFLAGS, LDFLAGS, extra_files
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   502
2022
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   503
    def PlugGenerate_C(self, buildpath, locations):
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   504
        """
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   505
        Generate C code
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   506
        @param current_location: Tupple containing plugin IEC location : %I0.0.4.5 => (0,0,4,5)
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   507
        @param locations: List of complete variables locations \
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   508
            [{"IEC_TYPE" : the IEC type (i.e. "INT", "STRING", ...)
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   509
            "NAME" : name of the variable (generally "__IW0_1_2" style)
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   510
            "DIR" : direction "Q","I" or "M"
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   511
            "SIZE" : size "X", "B", "W", "D", "L"
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   512
            "LOC" : tuple of interger for IEC location (0,1,2,...)
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   513
            }, ...]
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   514
        @return: [(C_file_name, CFLAGS),...] , LDFLAGS_TO_APPEND
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   515
        """
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   516
        current_location = self.GetCurrentLocation()
2032
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   517
        
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   518
        slaves = self.GetSlaves()
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   519
        for slave_pos in slaves:
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   520
            slave = self.GetSlave(slave_pos)
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   521
            if slave is not None:
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   522
                self.FileGenerator.DeclareSlave(slave_pos, slave.getType())
2022
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   523
        
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   524
        for location in locations:
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   525
            loc = location["LOC"][len(current_location):]
2032
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   526
            slave_pos = loc[:2]
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   527
            if slave_pos in slaves:
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   528
                self.FileGenerator.DeclareVariable(
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   529
                    slave_pos, loc[2], loc[3], location["IEC_TYPE"], location["DIR"], location["NAME"])
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   530
        
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   531
        return [],"",False
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   532
        
2022
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   533
#-------------------------------------------------------------------------------
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   534
#                      Current Buffering Management Functions
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   535
#-------------------------------------------------------------------------------
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   536
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   537
    """
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   538
    Return a copy of the config
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   539
    """
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   540
    def Copy(self, model):
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   541
        return cPickle.loads(cPickle.dumps(model))
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   542
    
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   543
    def CreateConfigBuffer(self, saved):
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   544
        self.ConfigBuffer = UndoBuffer(cPickle.dumps(self.Config), saved)
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   545
        
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   546
    def BufferConfig(self):
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   547
        self.ConfigBuffer.Buffering(cPickle.dumps(self.Config))
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   548
    
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   549
    def ConfigIsSaved(self):
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   550
        if self.ConfigBuffer is not None:
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   551
            return self.ConfigBuffer.IsCurrentSaved()
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   552
        else:
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   553
            return True
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   554
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   555
    def LoadPrevious(self):
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   556
        self.Config = cPickle.loads(self.ConfigBuffer.Previous())
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   557
    
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   558
    def LoadNext(self):
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   559
        self.Config = cPickle.loads(self.ConfigBuffer.Next())
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   560
    
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   561
    def GetBufferState(self):
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   562
        first = self.ConfigBuffer.IsFirst()
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   563
        last = self.ConfigBuffer.IsLast()
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   564
        return not first, not last
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   565
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   566
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   567
SLAVE_PDOS_CONFIGURATION_DECLARATION = """
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   568
/* Slave %(slave)d, "%(device_type)s"
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   569
 * Vendor ID:       0x%(vendor).8x
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   570
 * Product code:    0x%(product_code).8x
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   571
 * Revision number: 0x%(revision_number).8x
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   572
 */
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   573
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   574
ec_pdo_entry_info_t slave_%(slave)d_pdo_entries[] = {
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   575
%(pdos_entries_infos)s
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   576
};
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   577
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   578
ec_pdo_info_t slave_%(slave)d_pdos[] = {
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   579
%(pdos_infos)s
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   580
};
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   581
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   582
ec_sync_info_t slave_%(slave)d_syncs[] = {
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   583
%(pdos_sync_infos)s
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   584
    {0xff}
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   585
};
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   586
"""
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   587
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   588
SLAVE_CONFIGURATION_TEMPLATE = """
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   589
    if (!(slave%(slave)d = ecrt_master_slave_config(master, %(alias)d, %(position)d, 0x%(vendor).8x, 0x%(product_code).8x))) {
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   590
        fprintf(stderr, "Failed to get slave %(device_type)s configuration at alias %(alias)d and position %(position)d.\\n");
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   591
        return -1;
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   592
    }
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   593
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   594
    if (ecrt_slave_config_pdos(slave%(slave)d, EC_END, slave_%(slave)d_syncs)) {
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   595
        fprintf(stderr, "Failed to configure PDOs for slave %(device_type)s at alias %(alias)d and position %(position)d.\\n");
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   596
        return -1;
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   597
    }
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   598
"""
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   599
2032
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   600
SLAVE_INITIALIZATION_TEMPLATE = """
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   601
    {
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   602
        uint8_t value[] = {%(data)s};
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   603
        if (ecrt_master_sdo_download(master, %(slave)d, 0x%(index).4x, 0x%(subindex).2x, (uint8_t *)value, %(data_size)d, &abort_code)) {
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   604
            fprintf(stderr, "Failed to initialize slave %(device_type)s at alias %(alias)d and position %(position)d.\\nError: %%d\\n", abort_code);
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   605
            return -1;
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   606
        }
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   607
    }
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   608
"""
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   609
2029
7c848efa21c6 Adding support for displaying slave sync managers and profile object dictionary and for arbitrarily mapping variable through variable location
laurent
parents: 2026
diff changeset
   610
def ConfigureVariable(entry_infos, str_completion):
2032
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   611
    entry_infos["data_type"] = DATATYPECONVERSION.get(entry_infos["var_type"], None)
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   612
    if entry_infos["data_type"] is None:
2029
7c848efa21c6 Adding support for displaying slave sync managers and profile object dictionary and for arbitrarily mapping variable through variable location
laurent
parents: 2026
diff changeset
   613
        raise ValueError, _("Type of location \"%s\" not yet supported!") % entry_infos["var_name"]
2032
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   614
2034
ae8fecf082a1 Adding support for MCL
laurent
parents: 2032
diff changeset
   615
    entry_infos["real_var"] = "beremiz" + entry_infos["var_name"]
ae8fecf082a1 Adding support for MCL
laurent
parents: 2032
diff changeset
   616
    str_completion["located_variables_declaration"].extend(
ae8fecf082a1 Adding support for MCL
laurent
parents: 2032
diff changeset
   617
        ["IEC_%(var_type)s %(real_var)s;" % entry_infos,
ae8fecf082a1 Adding support for MCL
laurent
parents: 2032
diff changeset
   618
         "IEC_%(var_type)s *%(var_name)s = &%(real_var)s;" % entry_infos])
ae8fecf082a1 Adding support for MCL
laurent
parents: 2032
diff changeset
   619
    
ae8fecf082a1 Adding support for MCL
laurent
parents: 2032
diff changeset
   620
    str_completion["used_pdo_entry_offset_variables_declaration"].append(
ae8fecf082a1 Adding support for MCL
laurent
parents: 2032
diff changeset
   621
        "unsigned int slave%(slave)d_%(index).4x_%(subindex).2x;" % entry_infos)
2032
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   622
    
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   623
    if entry_infos["data_type"] == "BIT":
2034
ae8fecf082a1 Adding support for MCL
laurent
parents: 2032
diff changeset
   624
        str_completion["used_pdo_entry_offset_variables_declaration"].append(
ae8fecf082a1 Adding support for MCL
laurent
parents: 2032
diff changeset
   625
            "unsigned int slave%(slave)d_%(index).4x_%(subindex).2x_bit;" % entry_infos)
ae8fecf082a1 Adding support for MCL
laurent
parents: 2032
diff changeset
   626
        
ae8fecf082a1 Adding support for MCL
laurent
parents: 2032
diff changeset
   627
        str_completion["used_pdo_entry_configuration"].append(
ae8fecf082a1 Adding support for MCL
laurent
parents: 2032
diff changeset
   628
             ("    {%(alias)d, %(position)d, 0x%(vendor).8x, 0x%(product_code).8x, " + 
ae8fecf082a1 Adding support for MCL
laurent
parents: 2032
diff changeset
   629
              "0x%(index).4x, %(subindex)d, &slave%(slave)d_%(index).4x_%(subindex).2x, " + 
ae8fecf082a1 Adding support for MCL
laurent
parents: 2032
diff changeset
   630
              "&slave%(slave)d_%(index).4x_%(subindex).2x_bit},") % entry_infos)
ae8fecf082a1 Adding support for MCL
laurent
parents: 2032
diff changeset
   631
        
2032
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   632
        if entry_infos["dir"] == "I":
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   633
            str_completion["retrieve_variables"].append(
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   634
              ("    %(real_var)s = EC_READ_BIT(domain1_pd + slave%(slave)d_%(index).4x_%(subindex).2x, " + 
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   635
               "slave%(slave)d_%(index).4x_%(subindex).2x_bit);") % entry_infos)
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   636
        elif entry_infos["dir"] == "Q":
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   637
            str_completion["publish_variables"].append(
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   638
              ("    EC_WRITE_BIT(domain1_pd + slave%(slave)d_%(index).4x_%(subindex).2x, " + 
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   639
               "slave%(slave)d_%(index).4x_%(subindex).2x_bit, %(real_var)s);") % entry_infos)
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   640
    
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   641
    else:
2034
ae8fecf082a1 Adding support for MCL
laurent
parents: 2032
diff changeset
   642
        str_completion["used_pdo_entry_configuration"].append(
ae8fecf082a1 Adding support for MCL
laurent
parents: 2032
diff changeset
   643
            ("    {%(alias)d, %(position)d, 0x%(vendor).8x, 0x%(product_code).8x, 0x%(index).4x, " + 
ae8fecf082a1 Adding support for MCL
laurent
parents: 2032
diff changeset
   644
             "%(subindex)d, &slave%(slave)d_%(index).4x_%(subindex).2x},") % entry_infos)
ae8fecf082a1 Adding support for MCL
laurent
parents: 2032
diff changeset
   645
        
2032
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   646
        if entry_infos["dir"] == "I":
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   647
            str_completion["retrieve_variables"].append(
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   648
                ("    %(real_var)s = EC_READ_%(data_type)s(domain1_pd + " + 
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   649
                 "slave%(slave)d_%(index).4x_%(subindex).2x);") % entry_infos)
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   650
        elif entry_infos["dir"] == "Q":
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   651
            str_completion["publish_variables"].append(
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   652
                ("    EC_WRITE_%(data_type)s(domain1_pd + slave%(slave)d_%(index).4x_%(subindex).2x, " + 
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   653
                 "%(real_var)s);") % entry_infos)
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   654
2022
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   655
class _EthercatCFileGenerator:
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   656
    
2032
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   657
    def __init__(self, controler):
2022
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   658
        self.Controler = controler
2032
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   659
        
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   660
        self.Slaves = []
2022
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   661
        self.UsedVariables = {}
2032
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   662
2022
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   663
    def __del__(self):
2032
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   664
        self.Controler = None            
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   665
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   666
    def DeclareSlave(self, slave_identifier, slave):
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   667
        self.Slaves.append((slave_identifier, slave))
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   668
        self.Slaves.sort()
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   669
        return self.Slaves.index((slave_identifier, slave))
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   670
2034
ae8fecf082a1 Adding support for MCL
laurent
parents: 2032
diff changeset
   671
    def DeclareVariable(self, slave_identifier, index, subindex, iec_type, dir, name):
2022
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   672
        slave_variables = self.UsedVariables.setdefault(slave_identifier, {})
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   673
        
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   674
        entry_infos = slave_variables.get((index, subindex), None)
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   675
        if entry_infos is None:
2029
7c848efa21c6 Adding support for displaying slave sync managers and profile object dictionary and for arbitrarily mapping variable through variable location
laurent
parents: 2026
diff changeset
   676
            slave_variables[(index, subindex)] = {
7c848efa21c6 Adding support for displaying slave sync managers and profile object dictionary and for arbitrarily mapping variable through variable location
laurent
parents: 2026
diff changeset
   677
                "infos": (iec_type, dir, name),
7c848efa21c6 Adding support for displaying slave sync managers and profile object dictionary and for arbitrarily mapping variable through variable location
laurent
parents: 2026
diff changeset
   678
                "mapped": False}
7c848efa21c6 Adding support for displaying slave sync managers and profile object dictionary and for arbitrarily mapping variable through variable location
laurent
parents: 2026
diff changeset
   679
        elif entry_infos["infos"] != (iec_type, dir, name):
2022
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   680
            raise ValueError, _("Definition conflict for location \"%s\"") % name 
2029
7c848efa21c6 Adding support for displaying slave sync managers and profile object dictionary and for arbitrarily mapping variable through variable location
laurent
parents: 2026
diff changeset
   681
        
2032
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   682
    def GenerateCFile(self, filepath, location_str, etherlab_node_infos):
2022
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   683
        
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   684
        plc_etherlab_filepath = os.path.join(os.path.split(__file__)[0], "plc_etherlab.c")
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   685
        plc_etherlab_file = open(plc_etherlab_filepath, 'r')
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   686
        plc_etherlab_code = plc_etherlab_file.read()
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   687
        plc_etherlab_file.close()
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   688
        
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   689
        str_completion = {
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   690
            "location": location_str,
2032
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   691
            "configure_pdos": int(etherlab_node_infos.getConfigurePDOs()),
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   692
            "master_number": etherlab_node_infos.getMasterNumber(),
2022
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   693
            "located_variables_declaration": [],
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   694
            "used_pdo_entry_offset_variables_declaration": [],
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   695
            "used_pdo_entry_configuration": [],
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   696
            "pdos_configuration_declaration": "",
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   697
            "slaves_declaration": "",
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   698
            "slaves_configuration": "",
2032
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   699
            "slaves_initialization": "",
2022
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   700
            "retrieve_variables": [],
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   701
            "publish_variables": [],
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   702
        }
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   703
        
2029
7c848efa21c6 Adding support for displaying slave sync managers and profile object dictionary and for arbitrarily mapping variable through variable location
laurent
parents: 2026
diff changeset
   704
        for slave_entries in self.UsedVariables.itervalues():
7c848efa21c6 Adding support for displaying slave sync managers and profile object dictionary and for arbitrarily mapping variable through variable location
laurent
parents: 2026
diff changeset
   705
            for entry_infos in slave_entries.itervalues():
7c848efa21c6 Adding support for displaying slave sync managers and profile object dictionary and for arbitrarily mapping variable through variable location
laurent
parents: 2026
diff changeset
   706
                entry_infos["mapped"] = False
7c848efa21c6 Adding support for displaying slave sync managers and profile object dictionary and for arbitrarily mapping variable through variable location
laurent
parents: 2026
diff changeset
   707
        
2032
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   708
        for slave_idx, (slave_pos, type_infos) in enumerate(self.Slaves):
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   709
            
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   710
            device = self.Controler.GetModuleInfos(type_infos)
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   711
            if device is not None:
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   712
            
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   713
                slave_variables = self.UsedVariables.get(slave_pos, {})
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   714
                device_entries = device.GetEntriesList()
2022
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   715
                
2032
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   716
                if len(device.getTxPdo() + device.getRxPdo()) > 0 or len(slave_variables) > 0:
2022
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   717
                    
2032
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   718
                    for element in ["vendor", "product_code", "revision_number"]:
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   719
                        type_infos[element] = ExtractHexDecValue(type_infos[element])
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   720
                    type_infos.update(dict(zip(["slave", "alias", "position"], (slave_idx,) + slave_pos)))
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   721
                
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   722
                    str_completion["slaves_declaration"] += "static ec_slave_config_t *slave%(slave)d = NULL;\n" % type_infos
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   723
                    str_completion["slaves_configuration"] += SLAVE_CONFIGURATION_TEMPLATE % type_infos
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   724
    
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   725
                    for initCmd in device.getInitCmd():
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   726
                        index = ExtractHexDecValue(initCmd.getIndex())
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   727
                        subindex = ExtractHexDecValue(initCmd.getSubIndex())
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   728
                        entry = device_entries.get((index, subindex), None)
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   729
                        if entry is not None:
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   730
                            data_size = entry["BitSize"] / 8
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   731
                            data = ("%%.%dx" % (data_size * 2)) % initCmd.getData().getcontent()
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   732
                            data_str = ",".join(["0x%s" % data[i:i+2] for i in xrange(0, data_size * 2, 2)])
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   733
                            init_cmd_infos = {
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   734
                                "index": index,
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   735
                                "subindex": subindex,
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   736
                                "data": data_str,
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   737
                                "data_size": data_size
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   738
                            }
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   739
                            init_cmd_infos.update(type_infos)
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   740
                            str_completion["slaves_initialization"] += SLAVE_INITIALIZATION_TEMPLATE % init_cmd_infos
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   741
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   742
                    pdos_infos = {
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   743
                        "pdos_entries_infos": [],
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   744
                        "pdos_infos": [],
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   745
                        "pdos_sync_infos": [], 
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   746
                    }
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   747
                    pdos_infos.update(type_infos)
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   748
                    
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   749
                    sync_managers = []
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   750
                    for sync_manager_idx, sync_manager in enumerate(device.getSm()):
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   751
                        sync_manager_infos = {
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   752
                            "index": sync_manager_idx, 
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   753
                            "name": sync_manager.getcontent(),
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   754
                            "slave": slave_idx,
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   755
                            "pdos": [], 
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   756
                            "pdos_number": 0,
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   757
                        }
2022
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   758
                        
2032
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   759
                        sync_manager_control_byte = ExtractHexDecValue(sync_manager.getControlByte())
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   760
                        sync_manager_direction = sync_manager_control_byte & 0x0c
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   761
                        sync_manager_watchdog = sync_manager_control_byte & 0x40
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   762
                        if sync_manager_direction:
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   763
                            sync_manager_infos["sync_manager_type"] = "EC_DIR_OUTPUT"
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   764
                        else:
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   765
                            sync_manager_infos["sync_manager_type"] = "EC_DIR_INPUT"
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   766
                        if sync_manager_watchdog:
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   767
                            sync_manager_infos["watchdog"] = "EC_WD_ENABLE"
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   768
                        else:
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   769
                            sync_manager_infos["watchdog"] = "EC_WD_DISABLE"
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   770
                        
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   771
                        sync_managers.append(sync_manager_infos)
2022
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   772
                    
2032
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   773
                    pdos_index = []
2034
ae8fecf082a1 Adding support for MCL
laurent
parents: 2032
diff changeset
   774
                    excluded_pdos = []
2032
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   775
                    for only_mandatory in [True, False]:
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   776
                        for pdo, pdo_type in ([(pdo, "Inputs") for pdo in device.getTxPdo()] +
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   777
                                              [(pdo, "Outputs") for pdo in device.getRxPdo()]):
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   778
                            entries = pdo.getEntry()
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   779
                            
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   780
                            pdo_needed = pdo.getMandatory()
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   781
                            if pdo_needed is None:
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   782
                                pdo_needed = False
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   783
                            if only_mandatory != pdo_needed:
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   784
                                continue
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   785
                            
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   786
                            pdo_index = ExtractHexDecValue(pdo.getIndex().getcontent())
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   787
                            pdos_index.append(pdo_index)
2034
ae8fecf082a1 Adding support for MCL
laurent
parents: 2032
diff changeset
   788
                            if pdo_index in excluded_pdos:
ae8fecf082a1 Adding support for MCL
laurent
parents: 2032
diff changeset
   789
                                continue
ae8fecf082a1 Adding support for MCL
laurent
parents: 2032
diff changeset
   790
                            
2032
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   791
                            entries_infos = []
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   792
                            
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   793
                            for entry in entries:
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   794
                                index = ExtractHexDecValue(entry.getIndex().getcontent())
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   795
                                subindex = ExtractHexDecValue(entry.getSubIndex())
2029
7c848efa21c6 Adding support for displaying slave sync managers and profile object dictionary and for arbitrarily mapping variable through variable location
laurent
parents: 2026
diff changeset
   796
                                entry_infos = {
7c848efa21c6 Adding support for displaying slave sync managers and profile object dictionary and for arbitrarily mapping variable through variable location
laurent
parents: 2026
diff changeset
   797
                                    "index": index,
7c848efa21c6 Adding support for displaying slave sync managers and profile object dictionary and for arbitrarily mapping variable through variable location
laurent
parents: 2026
diff changeset
   798
                                    "subindex": subindex,
2032
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   799
                                    "name": ExtractName(entry.getName()),
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   800
                                    "bitlen": entry.getBitLen(),
2023
f9f884cf3033 Adding support for not configuring pdos when not mandatory and not needed by locations defined in PLC program. Adding support for displaying locations tree in Topology panel and BrowseLocationsDialog. Merging pdos grid and variables grid into one single grid in slave infos panel.
laurent
parents: 2022
diff changeset
   801
                                }
2029
7c848efa21c6 Adding support for displaying slave sync managers and profile object dictionary and for arbitrarily mapping variable through variable location
laurent
parents: 2026
diff changeset
   802
                                entry_infos.update(type_infos)
2032
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   803
                                entries_infos.append("    {0x%(index).4x, 0x%(subindex).2x, %(bitlen)d}, /* %(name)s */" % entry_infos)
2029
7c848efa21c6 Adding support for displaying slave sync managers and profile object dictionary and for arbitrarily mapping variable through variable location
laurent
parents: 2026
diff changeset
   804
                                
2032
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   805
                                entry_declaration = slave_variables.get((index, subindex), None)
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   806
                                if entry_declaration is not None and not entry_declaration["mapped"]:
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   807
                                    pdo_needed = True
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   808
                                    
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   809
                                    entry_infos.update(dict(zip(["var_type", "dir", "var_name"], entry_declaration["infos"])))
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   810
                                    entry_declaration["mapped"] = True
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   811
                                    
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   812
                                    if entry_infos["var_type"] != entry.getDataType().getcontent():
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   813
                                        raise ValueError, _("Wrong type for location \"%s\"!") % entry_infos["var_name"]
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   814
                                    
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   815
                                    if (entry_infos["dir"] == "I" and pdo_type != "Inputs" or 
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   816
                                        entry_infos["dir"] == "Q" and pdo_type != "Outputs"):
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   817
                                        raise ValueError, _("Wrong direction for location \"%s\"!") % entry_infos["var_name"]
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   818
                                    
2034
ae8fecf082a1 Adding support for MCL
laurent
parents: 2032
diff changeset
   819
                                    ConfigureVariable(entry_infos, str_completion)
ae8fecf082a1 Adding support for MCL
laurent
parents: 2032
diff changeset
   820
                                    
2032
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   821
                            if pdo_needed:
2034
ae8fecf082a1 Adding support for MCL
laurent
parents: 2032
diff changeset
   822
                                for excluded in pdo.getExclude():
ae8fecf082a1 Adding support for MCL
laurent
parents: 2032
diff changeset
   823
                                    excluded_index = ExtractHexDecValue(excluded.getcontent())
ae8fecf082a1 Adding support for MCL
laurent
parents: 2032
diff changeset
   824
                                    if excluded_index not in excluded_pdos:
ae8fecf082a1 Adding support for MCL
laurent
parents: 2032
diff changeset
   825
                                        excluded_pdos.append(excluded_index)
ae8fecf082a1 Adding support for MCL
laurent
parents: 2032
diff changeset
   826
                                
2032
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   827
                                sm = pdo.getSm()
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   828
                                if sm is None:
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   829
                                    for sm_idx, sync_manager in enumerate(sync_managers):
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   830
                                        if sync_manager["name"] == pdo_type:
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   831
                                            sm = sm_idx
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   832
                                if sm is None:
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   833
                                    raise ValueError, _("No sync manager available for %s pdo!") % pdo_type
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   834
                                    
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   835
                                sync_managers[sm]["pdos_number"] += 1
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   836
                                sync_managers[sm]["pdos"].append(
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   837
                                    {"slave": slave_idx,
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   838
                                     "index": pdo_index,
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   839
                                     "name": ExtractName(pdo.getName()),
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   840
                                     "type": pdo_type, 
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   841
                                     "entries": entries_infos,
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   842
                                     "entries_number": len(entries_infos),
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   843
                                     "fixed": pdo.getFixed() == True})
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   844
                    
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   845
                    dynamic_pdos = {}
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   846
                    dynamic_pdos_number = 0
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   847
                    for category, min_index, max_index in [("Inputs", 0x1600, 0x1800), 
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   848
                                                           ("Outputs", 0x1a00, 0x1C00)]:
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   849
                        for sync_manager in sync_managers:
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   850
                            if sync_manager["name"] == category:
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   851
                                category_infos = dynamic_pdos.setdefault(category, {})
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   852
                                category_infos["sync_manager"] = sync_manager
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   853
                                category_infos["pdos"] = [pdo for pdo in category_infos["sync_manager"]["pdos"] 
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   854
                                                          if not pdo["fixed"] and pdo["type"] == category]
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   855
                                category_infos["current_index"] = min_index
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   856
                                category_infos["max_index"] = max_index
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   857
                                break
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   858
                    
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   859
                    for (index, subindex), entry_declaration in slave_variables.iteritems():
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   860
                        
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   861
                        if not entry_declaration["mapped"]:
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   862
                            entry = device_entries.get((index, subindex), None)
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   863
                            if entry is None:
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   864
                                raise ValueError, _("Unknown entry index 0x%4.4x, subindex 0x%2.2x for device %s") % \
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   865
                                                 (index, subindex, type_infos["device_type"])
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   866
                            
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   867
                            entry_infos = {
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   868
                                "index": index,
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   869
                                "subindex": subindex,
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   870
                                "name": entry["Name"],
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   871
                                "bitlen": entry["BitSize"],
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   872
                            }
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   873
                            entry_infos.update(type_infos)
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   874
                            
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   875
                            entry_infos.update(dict(zip(["var_type", "dir", "var_name", "real_var"], entry_declaration["infos"])))
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   876
                            entry_declaration["mapped"] = True
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   877
                            
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   878
                            if entry_infos["var_type"] != entry["Type"]:
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   879
                                raise ValueError, _("Wrong type for location \"%s\"!") % entry_infos["var_name"]
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   880
                            
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   881
                            if entry_infos["dir"] == "I" and entry["PDOMapping"] in ["T", "RT"]:
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   882
                                pdo_type = "Inputs"
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   883
                            elif entry_infos["dir"] == "Q" and entry["PDOMapping"] in ["R", "RT"]:
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   884
                                pdo_type = "Outputs"
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   885
                            else:
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   886
                                raise ValueError, _("Wrong direction for location \"%s\"!") % entry_infos["var_name"]
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   887
                            
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   888
                            if not dynamic_pdos.has_key(pdo_type):
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   889
                                raise ValueError, _("No Sync manager defined for %s!") % pdo_type
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   890
                            
2034
ae8fecf082a1 Adding support for MCL
laurent
parents: 2032
diff changeset
   891
                            ConfigureVariable(entry_infos, str_completion)
2032
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   892
                            
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   893
                            if len(dynamic_pdos[pdo_type]["pdos"]) > 0:
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   894
                                pdo = dynamic_pdos[pdo_type]["pdos"][0]
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   895
                            else:
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   896
                                while dynamic_pdos[pdo_type]["current_index"] in pdos_index:
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   897
                                    dynamic_pdos[pdo_type]["current_index"] += 1
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   898
                                if dynamic_pdos[pdo_type]["current_index"] >= dynamic_pdos[pdo_type]["max_index"]:
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   899
                                    raise ValueError, _("No more free PDO index available for %s!") % pdo_type
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   900
                                pdos_index.append(dynamic_pdos[pdo_type]["current_index"])
2029
7c848efa21c6 Adding support for displaying slave sync managers and profile object dictionary and for arbitrarily mapping variable through variable location
laurent
parents: 2026
diff changeset
   901
                                
2032
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   902
                                dynamic_pdos_number += 1
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   903
                                pdo = {"slave": slave_idx,
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   904
                                       "index": dynamic_pdos[pdo_type]["current_index"],
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   905
                                       "name": "Dynamic PDO %d" % dynamic_pdos_number,
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   906
                                       "type": pdo_type, 
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   907
                                       "entries": [],
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   908
                                       "entries_number": 0,
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   909
                                       "fixed": False}
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   910
                                dynamic_pdos[pdo_type]["sync_manager"]["pdos_number"] += 1
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   911
                                dynamic_pdos[pdo_type]["sync_manager"]["pdos"].append(pdo)
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   912
                                dynamic_pdos[pdo_type]["pdos"].append(pdo)
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   913
                            
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   914
                            pdo["entries"].append("    {0x%(index).4x, 0x%(subindex).2x, %(bitlen)d}, /* %(name)s */" % entry_infos)
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   915
                            pdo["entries_number"] += 1
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   916
                            
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   917
                            if pdo["entries_number"] == 255:
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   918
                                dynamic_pdos[pdo_type]["pdos"].pop(0)
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   919
                            
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   920
                    pdo_offset = 0
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   921
                    entry_offset = 0
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   922
                    for sync_manager_infos in sync_managers:
2022
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   923
                        
2032
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   924
                        for pdo_infos in sync_manager_infos["pdos"]:
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   925
                            pdo_infos["offset"] = entry_offset
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   926
                            pdo_entries = pdo_infos["entries"]
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   927
                            pdos_infos["pdos_infos"].append(
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   928
                                ("    {0x%(index).4x, %(entries_number)d, " + 
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   929
                                 "slave_%(slave)d_pdo_entries + %(offset)d}, /* %(name)s */") % pdo_infos)
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   930
                            entry_offset += len(pdo_entries)
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   931
                            pdos_infos["pdos_entries_infos"].extend(pdo_entries)
2022
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   932
                        
2032
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   933
                        sync_manager_infos["offset"] = pdo_offset
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   934
                        pdos_infos["pdos_sync_infos"].append(
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   935
                            ("    {%(index)d, %(sync_manager_type)s, %(pdos_number)d, " + 
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   936
                             "slave_%(slave)d_pdos + %(offset)d, %(watchdog)s},") % sync_manager_infos)
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   937
                        pdo_offset += sync_manager_infos["pdos_number"]
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   938
                    
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   939
                    for element in ["pdos_entries_infos", "pdos_infos", "pdos_sync_infos"]:
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   940
                        pdos_infos[element] = "\n".join(pdos_infos[element])
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   941
                    
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   942
                    str_completion["pdos_configuration_declaration"] += SLAVE_PDOS_CONFIGURATION_DECLARATION % pdos_infos
2022
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   943
        
2023
f9f884cf3033 Adding support for not configuring pdos when not mandatory and not needed by locations defined in PLC program. Adding support for displaying locations tree in Topology panel and BrowseLocationsDialog. Merging pdos grid and variables grid into one single grid in slave infos panel.
laurent
parents: 2022
diff changeset
   944
        for element in ["used_pdo_entry_offset_variables_declaration", 
f9f884cf3033 Adding support for not configuring pdos when not mandatory and not needed by locations defined in PLC program. Adding support for displaying locations tree in Topology panel and BrowseLocationsDialog. Merging pdos grid and variables grid into one single grid in slave infos panel.
laurent
parents: 2022
diff changeset
   945
                        "used_pdo_entry_configuration", 
f9f884cf3033 Adding support for not configuring pdos when not mandatory and not needed by locations defined in PLC program. Adding support for displaying locations tree in Topology panel and BrowseLocationsDialog. Merging pdos grid and variables grid into one single grid in slave infos panel.
laurent
parents: 2022
diff changeset
   946
                        "located_variables_declaration", 
f9f884cf3033 Adding support for not configuring pdos when not mandatory and not needed by locations defined in PLC program. Adding support for displaying locations tree in Topology panel and BrowseLocationsDialog. Merging pdos grid and variables grid into one single grid in slave infos panel.
laurent
parents: 2022
diff changeset
   947
                        "retrieve_variables", 
f9f884cf3033 Adding support for not configuring pdos when not mandatory and not needed by locations defined in PLC program. Adding support for displaying locations tree in Topology panel and BrowseLocationsDialog. Merging pdos grid and variables grid into one single grid in slave infos panel.
laurent
parents: 2022
diff changeset
   948
                        "publish_variables"]:
2022
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   949
            str_completion[element] = "\n".join(str_completion[element])
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   950
        
2032
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   951
        etherlabfile = open(filepath, 'w')
2022
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   952
        etherlabfile.write(plc_etherlab_code % str_completion)
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   953
        etherlabfile.close()
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   954
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   955
#--------------------------------------------------
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   956
#                 Ethercat Plugin
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   957
#--------------------------------------------------
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   958
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   959
EtherCATInfoClasses = GenerateClassesFromXSD(os.path.join(os.path.dirname(__file__), "EtherCATInfo.xsd")) 
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
   960
2029
7c848efa21c6 Adding support for displaying slave sync managers and profile object dictionary and for arbitrarily mapping variable through variable location
laurent
parents: 2026
diff changeset
   961
cls = EtherCATInfoClasses["EtherCATInfo.xsd"].get("DeviceType", None)
7c848efa21c6 Adding support for displaying slave sync managers and profile object dictionary and for arbitrarily mapping variable through variable location
laurent
parents: 2026
diff changeset
   962
if cls:
7c848efa21c6 Adding support for displaying slave sync managers and profile object dictionary and for arbitrarily mapping variable through variable location
laurent
parents: 2026
diff changeset
   963
    cls.DataTypes = None
7c848efa21c6 Adding support for displaying slave sync managers and profile object dictionary and for arbitrarily mapping variable through variable location
laurent
parents: 2026
diff changeset
   964
    
2032
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   965
    def GetProfileNumbers(self):
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   966
        profiles = []
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   967
        
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   968
        for profile in self.getProfile():
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   969
            profile_content = profile.getcontent()
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   970
            if profile_content is None:
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   971
                continue
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   972
            
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   973
            for content_element in profile_content["value"]:
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   974
                if content_element["name"] == "ProfileNo":
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   975
                    profiles.append(content_element["value"])
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   976
        
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   977
        return profiles
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   978
    setattr(cls, "GetProfileNumbers", GetProfileNumbers)
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
   979
    
2029
7c848efa21c6 Adding support for displaying slave sync managers and profile object dictionary and for arbitrarily mapping variable through variable location
laurent
parents: 2026
diff changeset
   980
    def GetProfileDictionaries(self):
7c848efa21c6 Adding support for displaying slave sync managers and profile object dictionary and for arbitrarily mapping variable through variable location
laurent
parents: 2026
diff changeset
   981
        dictionaries = []
7c848efa21c6 Adding support for displaying slave sync managers and profile object dictionary and for arbitrarily mapping variable through variable location
laurent
parents: 2026
diff changeset
   982
        
7c848efa21c6 Adding support for displaying slave sync managers and profile object dictionary and for arbitrarily mapping variable through variable location
laurent
parents: 2026
diff changeset
   983
        for profile in self.getProfile():
7c848efa21c6 Adding support for displaying slave sync managers and profile object dictionary and for arbitrarily mapping variable through variable location
laurent
parents: 2026
diff changeset
   984
        
7c848efa21c6 Adding support for displaying slave sync managers and profile object dictionary and for arbitrarily mapping variable through variable location
laurent
parents: 2026
diff changeset
   985
            profile_content = profile.getcontent()
7c848efa21c6 Adding support for displaying slave sync managers and profile object dictionary and for arbitrarily mapping variable through variable location
laurent
parents: 2026
diff changeset
   986
            if profile_content is None:
2031
c6f32810723e Fix some issues regarding arbitrary variable mapping
laurent
parents: 2030
diff changeset
   987
                continue
2029
7c848efa21c6 Adding support for displaying slave sync managers and profile object dictionary and for arbitrarily mapping variable through variable location
laurent
parents: 2026
diff changeset
   988
            
7c848efa21c6 Adding support for displaying slave sync managers and profile object dictionary and for arbitrarily mapping variable through variable location
laurent
parents: 2026
diff changeset
   989
            for content_element in profile_content["value"]:
7c848efa21c6 Adding support for displaying slave sync managers and profile object dictionary and for arbitrarily mapping variable through variable location
laurent
parents: 2026
diff changeset
   990
                if content_element["name"] == "Dictionary":
7c848efa21c6 Adding support for displaying slave sync managers and profile object dictionary and for arbitrarily mapping variable through variable location
laurent
parents: 2026
diff changeset
   991
                    dictionaries.append(content_element["value"])
7c848efa21c6 Adding support for displaying slave sync managers and profile object dictionary and for arbitrarily mapping variable through variable location
laurent
parents: 2026
diff changeset
   992
                elif content_element["name"] == "DictionaryFile":
7c848efa21c6 Adding support for displaying slave sync managers and profile object dictionary and for arbitrarily mapping variable through variable location
laurent
parents: 2026
diff changeset
   993
                    raise ValueError, "DictionaryFile for defining Device Profile is not yet supported!"
7c848efa21c6 Adding support for displaying slave sync managers and profile object dictionary and for arbitrarily mapping variable through variable location
laurent
parents: 2026
diff changeset
   994
                
7c848efa21c6 Adding support for displaying slave sync managers and profile object dictionary and for arbitrarily mapping variable through variable location
laurent
parents: 2026
diff changeset
   995
        return dictionaries
7c848efa21c6 Adding support for displaying slave sync managers and profile object dictionary and for arbitrarily mapping variable through variable location
laurent
parents: 2026
diff changeset
   996
    setattr(cls, "GetProfileDictionaries", GetProfileDictionaries)
7c848efa21c6 Adding support for displaying slave sync managers and profile object dictionary and for arbitrarily mapping variable through variable location
laurent
parents: 2026
diff changeset
   997
    
7c848efa21c6 Adding support for displaying slave sync managers and profile object dictionary and for arbitrarily mapping variable through variable location
laurent
parents: 2026
diff changeset
   998
    def ExtractDataTypes(self):
7c848efa21c6 Adding support for displaying slave sync managers and profile object dictionary and for arbitrarily mapping variable through variable location
laurent
parents: 2026
diff changeset
   999
        self.DataTypes = {}
7c848efa21c6 Adding support for displaying slave sync managers and profile object dictionary and for arbitrarily mapping variable through variable location
laurent
parents: 2026
diff changeset
  1000
        
7c848efa21c6 Adding support for displaying slave sync managers and profile object dictionary and for arbitrarily mapping variable through variable location
laurent
parents: 2026
diff changeset
  1001
        for dictionary in self.GetProfileDictionaries():
7c848efa21c6 Adding support for displaying slave sync managers and profile object dictionary and for arbitrarily mapping variable through variable location
laurent
parents: 2026
diff changeset
  1002
            
7c848efa21c6 Adding support for displaying slave sync managers and profile object dictionary and for arbitrarily mapping variable through variable location
laurent
parents: 2026
diff changeset
  1003
            datatypes = dictionary.getDataTypes()
7c848efa21c6 Adding support for displaying slave sync managers and profile object dictionary and for arbitrarily mapping variable through variable location
laurent
parents: 2026
diff changeset
  1004
            if datatypes is not None:
7c848efa21c6 Adding support for displaying slave sync managers and profile object dictionary and for arbitrarily mapping variable through variable location
laurent
parents: 2026
diff changeset
  1005
                
7c848efa21c6 Adding support for displaying slave sync managers and profile object dictionary and for arbitrarily mapping variable through variable location
laurent
parents: 2026
diff changeset
  1006
                for datatype in datatypes.getDataType():
7c848efa21c6 Adding support for displaying slave sync managers and profile object dictionary and for arbitrarily mapping variable through variable location
laurent
parents: 2026
diff changeset
  1007
                    content = datatype.getcontent()
7c848efa21c6 Adding support for displaying slave sync managers and profile object dictionary and for arbitrarily mapping variable through variable location
laurent
parents: 2026
diff changeset
  1008
                    if content is not None and content["name"] == "SubItem":
7c848efa21c6 Adding support for displaying slave sync managers and profile object dictionary and for arbitrarily mapping variable through variable location
laurent
parents: 2026
diff changeset
  1009
                        self.DataTypes[datatype.getName()] = datatype
7c848efa21c6 Adding support for displaying slave sync managers and profile object dictionary and for arbitrarily mapping variable through variable location
laurent
parents: 2026
diff changeset
  1010
    
7c848efa21c6 Adding support for displaying slave sync managers and profile object dictionary and for arbitrarily mapping variable through variable location
laurent
parents: 2026
diff changeset
  1011
    setattr(cls, "ExtractDataTypes", ExtractDataTypes)
7c848efa21c6 Adding support for displaying slave sync managers and profile object dictionary and for arbitrarily mapping variable through variable location
laurent
parents: 2026
diff changeset
  1012
    
2032
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
  1013
    def getInitCmd(self):
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
  1014
        mailbox = self.getMailbox()
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
  1015
        if mailbox is None:
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
  1016
            return []
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
  1017
        
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
  1018
        coe = mailbox.getCoE()
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
  1019
        if coe is None:
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
  1020
            return []
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
  1021
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
  1022
        return coe.getInitCmd()
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
  1023
    setattr(cls, "getInitCmd", getInitCmd)
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
  1024
2029
7c848efa21c6 Adding support for displaying slave sync managers and profile object dictionary and for arbitrarily mapping variable through variable location
laurent
parents: 2026
diff changeset
  1025
    def GetEntriesList(self):
7c848efa21c6 Adding support for displaying slave sync managers and profile object dictionary and for arbitrarily mapping variable through variable location
laurent
parents: 2026
diff changeset
  1026
        if self.DataTypes is None:
7c848efa21c6 Adding support for displaying slave sync managers and profile object dictionary and for arbitrarily mapping variable through variable location
laurent
parents: 2026
diff changeset
  1027
            self.ExtractDataTypes()
7c848efa21c6 Adding support for displaying slave sync managers and profile object dictionary and for arbitrarily mapping variable through variable location
laurent
parents: 2026
diff changeset
  1028
        
7c848efa21c6 Adding support for displaying slave sync managers and profile object dictionary and for arbitrarily mapping variable through variable location
laurent
parents: 2026
diff changeset
  1029
        entries = {}
7c848efa21c6 Adding support for displaying slave sync managers and profile object dictionary and for arbitrarily mapping variable through variable location
laurent
parents: 2026
diff changeset
  1030
        
7c848efa21c6 Adding support for displaying slave sync managers and profile object dictionary and for arbitrarily mapping variable through variable location
laurent
parents: 2026
diff changeset
  1031
        for dictionary in self.GetProfileDictionaries():
7c848efa21c6 Adding support for displaying slave sync managers and profile object dictionary and for arbitrarily mapping variable through variable location
laurent
parents: 2026
diff changeset
  1032
            
7c848efa21c6 Adding support for displaying slave sync managers and profile object dictionary and for arbitrarily mapping variable through variable location
laurent
parents: 2026
diff changeset
  1033
            for object in dictionary.getObjects().getObject():
7c848efa21c6 Adding support for displaying slave sync managers and profile object dictionary and for arbitrarily mapping variable through variable location
laurent
parents: 2026
diff changeset
  1034
                entry_index = object.getIndex().getcontent()
7c848efa21c6 Adding support for displaying slave sync managers and profile object dictionary and for arbitrarily mapping variable through variable location
laurent
parents: 2026
diff changeset
  1035
                index = ExtractHexDecValue(entry_index)
7c848efa21c6 Adding support for displaying slave sync managers and profile object dictionary and for arbitrarily mapping variable through variable location
laurent
parents: 2026
diff changeset
  1036
                entry_type = object.getType()
7c848efa21c6 Adding support for displaying slave sync managers and profile object dictionary and for arbitrarily mapping variable through variable location
laurent
parents: 2026
diff changeset
  1037
                entry_name = ExtractName(object.getName())
7c848efa21c6 Adding support for displaying slave sync managers and profile object dictionary and for arbitrarily mapping variable through variable location
laurent
parents: 2026
diff changeset
  1038
                
7c848efa21c6 Adding support for displaying slave sync managers and profile object dictionary and for arbitrarily mapping variable through variable location
laurent
parents: 2026
diff changeset
  1039
                entry_type_infos = self.DataTypes.get(entry_type, None)
7c848efa21c6 Adding support for displaying slave sync managers and profile object dictionary and for arbitrarily mapping variable through variable location
laurent
parents: 2026
diff changeset
  1040
                if entry_type_infos is not None:
7c848efa21c6 Adding support for displaying slave sync managers and profile object dictionary and for arbitrarily mapping variable through variable location
laurent
parents: 2026
diff changeset
  1041
                    content = entry_type_infos.getcontent()
7c848efa21c6 Adding support for displaying slave sync managers and profile object dictionary and for arbitrarily mapping variable through variable location
laurent
parents: 2026
diff changeset
  1042
                    for subitem in content["value"]:
7c848efa21c6 Adding support for displaying slave sync managers and profile object dictionary and for arbitrarily mapping variable through variable location
laurent
parents: 2026
diff changeset
  1043
                        entry_subidx = subitem.getSubIdx()
7c848efa21c6 Adding support for displaying slave sync managers and profile object dictionary and for arbitrarily mapping variable through variable location
laurent
parents: 2026
diff changeset
  1044
                        if entry_subidx is None:
7c848efa21c6 Adding support for displaying slave sync managers and profile object dictionary and for arbitrarily mapping variable through variable location
laurent
parents: 2026
diff changeset
  1045
                            entry_subidx = "0"
7c848efa21c6 Adding support for displaying slave sync managers and profile object dictionary and for arbitrarily mapping variable through variable location
laurent
parents: 2026
diff changeset
  1046
                        subidx = ExtractHexDecValue(entry_subidx)
7c848efa21c6 Adding support for displaying slave sync managers and profile object dictionary and for arbitrarily mapping variable through variable location
laurent
parents: 2026
diff changeset
  1047
                        subitem_access = ""
2032
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
  1048
                        subitem_pdomapping = ""
2029
7c848efa21c6 Adding support for displaying slave sync managers and profile object dictionary and for arbitrarily mapping variable through variable location
laurent
parents: 2026
diff changeset
  1049
                        subitem_flags = subitem.getFlags()
7c848efa21c6 Adding support for displaying slave sync managers and profile object dictionary and for arbitrarily mapping variable through variable location
laurent
parents: 2026
diff changeset
  1050
                        if subitem_flags is not None:
7c848efa21c6 Adding support for displaying slave sync managers and profile object dictionary and for arbitrarily mapping variable through variable location
laurent
parents: 2026
diff changeset
  1051
                            access = subitem_flags.getAccess()
7c848efa21c6 Adding support for displaying slave sync managers and profile object dictionary and for arbitrarily mapping variable through variable location
laurent
parents: 2026
diff changeset
  1052
                            if access is not None:
7c848efa21c6 Adding support for displaying slave sync managers and profile object dictionary and for arbitrarily mapping variable through variable location
laurent
parents: 2026
diff changeset
  1053
                                subitem_access = access.getcontent()
2032
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
  1054
                            pdomapping = subitem_flags.getPdoMapping()
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
  1055
                            if pdomapping is not None:
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
  1056
                                subitem_pdomapping = pdomapping.upper()
2029
7c848efa21c6 Adding support for displaying slave sync managers and profile object dictionary and for arbitrarily mapping variable through variable location
laurent
parents: 2026
diff changeset
  1057
                        entries[(index, subidx)] = {
7c848efa21c6 Adding support for displaying slave sync managers and profile object dictionary and for arbitrarily mapping variable through variable location
laurent
parents: 2026
diff changeset
  1058
                            "Index": entry_index,
7c848efa21c6 Adding support for displaying slave sync managers and profile object dictionary and for arbitrarily mapping variable through variable location
laurent
parents: 2026
diff changeset
  1059
                            "SubIndex": entry_subidx,
7c848efa21c6 Adding support for displaying slave sync managers and profile object dictionary and for arbitrarily mapping variable through variable location
laurent
parents: 2026
diff changeset
  1060
                            "Name": "%s - %s" % 
7c848efa21c6 Adding support for displaying slave sync managers and profile object dictionary and for arbitrarily mapping variable through variable location
laurent
parents: 2026
diff changeset
  1061
                                    (entry_name.decode("utf-8"),
7c848efa21c6 Adding support for displaying slave sync managers and profile object dictionary and for arbitrarily mapping variable through variable location
laurent
parents: 2026
diff changeset
  1062
                                     ExtractName(subitem.getDisplayName(), 
7c848efa21c6 Adding support for displaying slave sync managers and profile object dictionary and for arbitrarily mapping variable through variable location
laurent
parents: 2026
diff changeset
  1063
                                                 subitem.getName()).decode("utf-8")),
7c848efa21c6 Adding support for displaying slave sync managers and profile object dictionary and for arbitrarily mapping variable through variable location
laurent
parents: 2026
diff changeset
  1064
                            "Type": subitem.getType(),
7c848efa21c6 Adding support for displaying slave sync managers and profile object dictionary and for arbitrarily mapping variable through variable location
laurent
parents: 2026
diff changeset
  1065
                            "BitSize": subitem.getBitSize(),
7c848efa21c6 Adding support for displaying slave sync managers and profile object dictionary and for arbitrarily mapping variable through variable location
laurent
parents: 2026
diff changeset
  1066
                            "Access": subitem_access, 
2032
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
  1067
                            "PDOMapping": subitem_pdomapping, 
2029
7c848efa21c6 Adding support for displaying slave sync managers and profile object dictionary and for arbitrarily mapping variable through variable location
laurent
parents: 2026
diff changeset
  1068
                            "PDO index": "", 
7c848efa21c6 Adding support for displaying slave sync managers and profile object dictionary and for arbitrarily mapping variable through variable location
laurent
parents: 2026
diff changeset
  1069
                            "PDO name": "", 
7c848efa21c6 Adding support for displaying slave sync managers and profile object dictionary and for arbitrarily mapping variable through variable location
laurent
parents: 2026
diff changeset
  1070
                            "PDO type": ""}
7c848efa21c6 Adding support for displaying slave sync managers and profile object dictionary and for arbitrarily mapping variable through variable location
laurent
parents: 2026
diff changeset
  1071
                else:
7c848efa21c6 Adding support for displaying slave sync managers and profile object dictionary and for arbitrarily mapping variable through variable location
laurent
parents: 2026
diff changeset
  1072
                    entry_access = ""
2032
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
  1073
                    entry_pdomapping = ""
2029
7c848efa21c6 Adding support for displaying slave sync managers and profile object dictionary and for arbitrarily mapping variable through variable location
laurent
parents: 2026
diff changeset
  1074
                    entry_flags = object.getFlags()
7c848efa21c6 Adding support for displaying slave sync managers and profile object dictionary and for arbitrarily mapping variable through variable location
laurent
parents: 2026
diff changeset
  1075
                    if entry_flags is not None:
7c848efa21c6 Adding support for displaying slave sync managers and profile object dictionary and for arbitrarily mapping variable through variable location
laurent
parents: 2026
diff changeset
  1076
                        access = entry_flags.getAccess()
7c848efa21c6 Adding support for displaying slave sync managers and profile object dictionary and for arbitrarily mapping variable through variable location
laurent
parents: 2026
diff changeset
  1077
                        if access is not None:
7c848efa21c6 Adding support for displaying slave sync managers and profile object dictionary and for arbitrarily mapping variable through variable location
laurent
parents: 2026
diff changeset
  1078
                            entry_access = access.getcontent()
2032
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
  1079
                        pdomapping = entry_flags.getPdoMapping()
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
  1080
                        if pdomapping is not None:
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
  1081
                            entry_pdomapping = pdomapping.upper()
2029
7c848efa21c6 Adding support for displaying slave sync managers and profile object dictionary and for arbitrarily mapping variable through variable location
laurent
parents: 2026
diff changeset
  1082
                    entries[(index, 0)] = {
7c848efa21c6 Adding support for displaying slave sync managers and profile object dictionary and for arbitrarily mapping variable through variable location
laurent
parents: 2026
diff changeset
  1083
                         "Index": entry_index,
7c848efa21c6 Adding support for displaying slave sync managers and profile object dictionary and for arbitrarily mapping variable through variable location
laurent
parents: 2026
diff changeset
  1084
                         "SubIndex": "0",
7c848efa21c6 Adding support for displaying slave sync managers and profile object dictionary and for arbitrarily mapping variable through variable location
laurent
parents: 2026
diff changeset
  1085
                         "Name": entry_name,
7c848efa21c6 Adding support for displaying slave sync managers and profile object dictionary and for arbitrarily mapping variable through variable location
laurent
parents: 2026
diff changeset
  1086
                         "Type": entry_type,
7c848efa21c6 Adding support for displaying slave sync managers and profile object dictionary and for arbitrarily mapping variable through variable location
laurent
parents: 2026
diff changeset
  1087
                         "BitSize": object.getBitSize(),
7c848efa21c6 Adding support for displaying slave sync managers and profile object dictionary and for arbitrarily mapping variable through variable location
laurent
parents: 2026
diff changeset
  1088
                         "Access": entry_access,
2032
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
  1089
                         "PDOMapping": entry_pdomapping, 
2029
7c848efa21c6 Adding support for displaying slave sync managers and profile object dictionary and for arbitrarily mapping variable through variable location
laurent
parents: 2026
diff changeset
  1090
                         "PDO index": "", 
7c848efa21c6 Adding support for displaying slave sync managers and profile object dictionary and for arbitrarily mapping variable through variable location
laurent
parents: 2026
diff changeset
  1091
                         "PDO name": "", 
7c848efa21c6 Adding support for displaying slave sync managers and profile object dictionary and for arbitrarily mapping variable through variable location
laurent
parents: 2026
diff changeset
  1092
                         "PDO type": ""}
7c848efa21c6 Adding support for displaying slave sync managers and profile object dictionary and for arbitrarily mapping variable through variable location
laurent
parents: 2026
diff changeset
  1093
        
7c848efa21c6 Adding support for displaying slave sync managers and profile object dictionary and for arbitrarily mapping variable through variable location
laurent
parents: 2026
diff changeset
  1094
        for TxPdo in self.getTxPdo():
7c848efa21c6 Adding support for displaying slave sync managers and profile object dictionary and for arbitrarily mapping variable through variable location
laurent
parents: 2026
diff changeset
  1095
            ExtractPdoInfos(TxPdo, "Transmit", entries)
7c848efa21c6 Adding support for displaying slave sync managers and profile object dictionary and for arbitrarily mapping variable through variable location
laurent
parents: 2026
diff changeset
  1096
        for RxPdo in self.getRxPdo():
7c848efa21c6 Adding support for displaying slave sync managers and profile object dictionary and for arbitrarily mapping variable through variable location
laurent
parents: 2026
diff changeset
  1097
            ExtractPdoInfos(RxPdo, "Receive", entries)
7c848efa21c6 Adding support for displaying slave sync managers and profile object dictionary and for arbitrarily mapping variable through variable location
laurent
parents: 2026
diff changeset
  1098
        
7c848efa21c6 Adding support for displaying slave sync managers and profile object dictionary and for arbitrarily mapping variable through variable location
laurent
parents: 2026
diff changeset
  1099
        return entries
7c848efa21c6 Adding support for displaying slave sync managers and profile object dictionary and for arbitrarily mapping variable through variable location
laurent
parents: 2026
diff changeset
  1100
    setattr(cls, "GetEntriesList", GetEntriesList)
7c848efa21c6 Adding support for displaying slave sync managers and profile object dictionary and for arbitrarily mapping variable through variable location
laurent
parents: 2026
diff changeset
  1101
7c848efa21c6 Adding support for displaying slave sync managers and profile object dictionary and for arbitrarily mapping variable through variable location
laurent
parents: 2026
diff changeset
  1102
    def GetSyncManagers(self):
7c848efa21c6 Adding support for displaying slave sync managers and profile object dictionary and for arbitrarily mapping variable through variable location
laurent
parents: 2026
diff changeset
  1103
        sync_managers = []
7c848efa21c6 Adding support for displaying slave sync managers and profile object dictionary and for arbitrarily mapping variable through variable location
laurent
parents: 2026
diff changeset
  1104
        for sync_manager in self.getSm():
7c848efa21c6 Adding support for displaying slave sync managers and profile object dictionary and for arbitrarily mapping variable through variable location
laurent
parents: 2026
diff changeset
  1105
            sync_manager_infos = {}
7c848efa21c6 Adding support for displaying slave sync managers and profile object dictionary and for arbitrarily mapping variable through variable location
laurent
parents: 2026
diff changeset
  1106
            for name, value in [("Name", sync_manager.getcontent()),
7c848efa21c6 Adding support for displaying slave sync managers and profile object dictionary and for arbitrarily mapping variable through variable location
laurent
parents: 2026
diff changeset
  1107
                                ("Start Address", sync_manager.getStartAddress()),
7c848efa21c6 Adding support for displaying slave sync managers and profile object dictionary and for arbitrarily mapping variable through variable location
laurent
parents: 2026
diff changeset
  1108
                                ("Default Size", sync_manager.getDefaultSize()),
7c848efa21c6 Adding support for displaying slave sync managers and profile object dictionary and for arbitrarily mapping variable through variable location
laurent
parents: 2026
diff changeset
  1109
                                ("Control Byte", sync_manager.getControlByte()),
7c848efa21c6 Adding support for displaying slave sync managers and profile object dictionary and for arbitrarily mapping variable through variable location
laurent
parents: 2026
diff changeset
  1110
                                ("Enable", sync_manager.getEnable())]:
7c848efa21c6 Adding support for displaying slave sync managers and profile object dictionary and for arbitrarily mapping variable through variable location
laurent
parents: 2026
diff changeset
  1111
                if value is None:
7c848efa21c6 Adding support for displaying slave sync managers and profile object dictionary and for arbitrarily mapping variable through variable location
laurent
parents: 2026
diff changeset
  1112
                    value =""
7c848efa21c6 Adding support for displaying slave sync managers and profile object dictionary and for arbitrarily mapping variable through variable location
laurent
parents: 2026
diff changeset
  1113
                sync_manager_infos[name] = value
7c848efa21c6 Adding support for displaying slave sync managers and profile object dictionary and for arbitrarily mapping variable through variable location
laurent
parents: 2026
diff changeset
  1114
            sync_managers.append(sync_manager_infos)
7c848efa21c6 Adding support for displaying slave sync managers and profile object dictionary and for arbitrarily mapping variable through variable location
laurent
parents: 2026
diff changeset
  1115
        return sync_managers
7c848efa21c6 Adding support for displaying slave sync managers and profile object dictionary and for arbitrarily mapping variable through variable location
laurent
parents: 2026
diff changeset
  1116
    setattr(cls, "GetSyncManagers", GetSyncManagers)
7c848efa21c6 Adding support for displaying slave sync managers and profile object dictionary and for arbitrarily mapping variable through variable location
laurent
parents: 2026
diff changeset
  1117
2022
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
  1118
def GroupItemCompare(x, y):
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
  1119
    if x["type"] == y["type"]:
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
  1120
        if x["type"] == ETHERCAT_GROUP:
2031
c6f32810723e Fix some issues regarding arbitrary variable mapping
laurent
parents: 2030
diff changeset
  1121
            return cmp(x["order"], y["order"])
2022
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
  1122
        else:
2031
c6f32810723e Fix some issues regarding arbitrary variable mapping
laurent
parents: 2030
diff changeset
  1123
            return cmp(x["name"], y["name"])
2022
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
  1124
    elif x["type"] == ETHERCAT_GROUP:
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
  1125
        return -1
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
  1126
    return 1
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
  1127
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
  1128
def SortGroupItems(group):
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
  1129
    for item in group["children"]:
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
  1130
        if item["type"] == ETHERCAT_GROUP:
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
  1131
            SortGroupItems(item)
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
  1132
    group["children"].sort(GroupItemCompare)
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
  1133
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
  1134
def ExtractName(names, default=None):
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
  1135
    if len(names) == 1:
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
  1136
        return names[0].getcontent()
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
  1137
    else:
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
  1138
        for name in names:
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
  1139
            if name.getLcId() == 1033:
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
  1140
                return name.getcontent()
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
  1141
    return default
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
  1142
2029
7c848efa21c6 Adding support for displaying slave sync managers and profile object dictionary and for arbitrarily mapping variable through variable location
laurent
parents: 2026
diff changeset
  1143
def ExtractPdoInfos(pdo, pdo_type, entries):
2022
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
  1144
    pdo_index = pdo.getIndex().getcontent()
2029
7c848efa21c6 Adding support for displaying slave sync managers and profile object dictionary and for arbitrarily mapping variable through variable location
laurent
parents: 2026
diff changeset
  1145
    pdo_name = ExtractName(pdo.getName())
7c848efa21c6 Adding support for displaying slave sync managers and profile object dictionary and for arbitrarily mapping variable through variable location
laurent
parents: 2026
diff changeset
  1146
    for pdo_entry in pdo.getEntry():
7c848efa21c6 Adding support for displaying slave sync managers and profile object dictionary and for arbitrarily mapping variable through variable location
laurent
parents: 2026
diff changeset
  1147
        entry_index = pdo_entry.getIndex().getcontent()
7c848efa21c6 Adding support for displaying slave sync managers and profile object dictionary and for arbitrarily mapping variable through variable location
laurent
parents: 2026
diff changeset
  1148
        entry_subindex = pdo_entry.getSubIndex()
7c848efa21c6 Adding support for displaying slave sync managers and profile object dictionary and for arbitrarily mapping variable through variable location
laurent
parents: 2026
diff changeset
  1149
        index = ExtractHexDecValue(entry_index)
7c848efa21c6 Adding support for displaying slave sync managers and profile object dictionary and for arbitrarily mapping variable through variable location
laurent
parents: 2026
diff changeset
  1150
        subindex = ExtractHexDecValue(entry_subindex)
7c848efa21c6 Adding support for displaying slave sync managers and profile object dictionary and for arbitrarily mapping variable through variable location
laurent
parents: 2026
diff changeset
  1151
        
7c848efa21c6 Adding support for displaying slave sync managers and profile object dictionary and for arbitrarily mapping variable through variable location
laurent
parents: 2026
diff changeset
  1152
        entry = entries.get((index, subindex), None)
7c848efa21c6 Adding support for displaying slave sync managers and profile object dictionary and for arbitrarily mapping variable through variable location
laurent
parents: 2026
diff changeset
  1153
        if entry is not None:
7c848efa21c6 Adding support for displaying slave sync managers and profile object dictionary and for arbitrarily mapping variable through variable location
laurent
parents: 2026
diff changeset
  1154
            entry["PDO index"] = pdo_index
7c848efa21c6 Adding support for displaying slave sync managers and profile object dictionary and for arbitrarily mapping variable through variable location
laurent
parents: 2026
diff changeset
  1155
            entry["PDO name"] = pdo_name
7c848efa21c6 Adding support for displaying slave sync managers and profile object dictionary and for arbitrarily mapping variable through variable location
laurent
parents: 2026
diff changeset
  1156
            entry["PDO type"] = pdo_type
7c848efa21c6 Adding support for displaying slave sync managers and profile object dictionary and for arbitrarily mapping variable through variable location
laurent
parents: 2026
diff changeset
  1157
        else:
2031
c6f32810723e Fix some issues regarding arbitrary variable mapping
laurent
parents: 2030
diff changeset
  1158
            entry_type = pdo_entry.getDataType()
c6f32810723e Fix some issues regarding arbitrary variable mapping
laurent
parents: 2030
diff changeset
  1159
            if entry_type is not None:
c6f32810723e Fix some issues regarding arbitrary variable mapping
laurent
parents: 2030
diff changeset
  1160
                if pdo_type == "Transmit":
c6f32810723e Fix some issues regarding arbitrary variable mapping
laurent
parents: 2030
diff changeset
  1161
                    access = "ro"
2032
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
  1162
                    pdomapping = "T"
2031
c6f32810723e Fix some issues regarding arbitrary variable mapping
laurent
parents: 2030
diff changeset
  1163
                else:
c6f32810723e Fix some issues regarding arbitrary variable mapping
laurent
parents: 2030
diff changeset
  1164
                    access = "wo"
2032
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
  1165
                    pdomapping = "R"
2031
c6f32810723e Fix some issues regarding arbitrary variable mapping
laurent
parents: 2030
diff changeset
  1166
                entries[(index, subindex)] = {
c6f32810723e Fix some issues regarding arbitrary variable mapping
laurent
parents: 2030
diff changeset
  1167
                    "Index": entry_index,
c6f32810723e Fix some issues regarding arbitrary variable mapping
laurent
parents: 2030
diff changeset
  1168
                    "SubIndex": entry_subindex,
c6f32810723e Fix some issues regarding arbitrary variable mapping
laurent
parents: 2030
diff changeset
  1169
                    "Name": ExtractName(pdo_entry.getName()),
c6f32810723e Fix some issues regarding arbitrary variable mapping
laurent
parents: 2030
diff changeset
  1170
                    "Type": entry_type.getcontent(),
c6f32810723e Fix some issues regarding arbitrary variable mapping
laurent
parents: 2030
diff changeset
  1171
                    "Access": access,
2032
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
  1172
                    "PDOMapping": pdomapping,
2031
c6f32810723e Fix some issues regarding arbitrary variable mapping
laurent
parents: 2030
diff changeset
  1173
                    "PDO index": pdo_index, 
c6f32810723e Fix some issues regarding arbitrary variable mapping
laurent
parents: 2030
diff changeset
  1174
                    "PDO name": pdo_name, 
c6f32810723e Fix some issues regarding arbitrary variable mapping
laurent
parents: 2030
diff changeset
  1175
                    "PDO type": pdo_type}
2022
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
  1176
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
  1177
class RootClass:
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
  1178
    
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
  1179
    PlugChildsTypes = [("EthercatNode",_EthercatPlug,"Ethercat Master")]
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
  1180
    
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
  1181
    def __init__(self):
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
  1182
        self.LoadModulesLibrary()
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
  1183
    
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
  1184
    def GetModulesLibraryPath(self):
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
  1185
        library_path = os.path.join(self.PlugPath(), "modules")
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
  1186
        if not os.path.exists(library_path):
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
  1187
            os.mkdir(library_path)
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
  1188
        return library_path
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
  1189
    
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
  1190
    def _ImportModuleLibrary(self):
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
  1191
        dialog = wx.FileDialog(self.GetPlugRoot().AppFrame, _("Choose an XML file"), os.getcwd(), "",  _("XML files (*.xml)|*.xml|All files|*.*"), wx.OPEN)
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
  1192
        if dialog.ShowModal() == wx.ID_OK:
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
  1193
            filepath = dialog.GetPath()
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
  1194
            if os.path.isfile(filepath):
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
  1195
                shutil.copy(filepath, self.GetModulesLibraryPath())
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
  1196
                self.LoadModulesLibrary()
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
  1197
            else:
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
  1198
                self.GetPlugRoot().logger.write_error(_("No such XML file: %s\n") % filepath)
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
  1199
        dialog.Destroy()  
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
  1200
    
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
  1201
    PluginMethods = [
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
  1202
        {"bitmap" : os.path.join("images", "ImportDEF"),
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
  1203
         "name" : _("Import module library"), 
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
  1204
         "tooltip" : _("Import module library"),
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
  1205
         "method" : "_ImportModuleLibrary"},
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
  1206
    ]
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
  1207
    
2023
f9f884cf3033 Adding support for not configuring pdos when not mandatory and not needed by locations defined in PLC program. Adding support for displaying locations tree in Topology panel and BrowseLocationsDialog. Merging pdos grid and variables grid into one single grid in slave infos panel.
laurent
parents: 2022
diff changeset
  1208
    def PlugGenerate_C(self, buildpath, locations):
f9f884cf3033 Adding support for not configuring pdos when not mandatory and not needed by locations defined in PLC program. Adding support for displaying locations tree in Topology panel and BrowseLocationsDialog. Merging pdos grid and variables grid into one single grid in slave infos panel.
laurent
parents: 2022
diff changeset
  1209
        return [],"",False
f9f884cf3033 Adding support for not configuring pdos when not mandatory and not needed by locations defined in PLC program. Adding support for displaying locations tree in Topology panel and BrowseLocationsDialog. Merging pdos grid and variables grid into one single grid in slave infos panel.
laurent
parents: 2022
diff changeset
  1210
    
2022
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
  1211
    def LoadModulesLibrary(self):
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
  1212
        self.ModulesLibrary = {}
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
  1213
        
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
  1214
        library_path = self.GetModulesLibraryPath()
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
  1215
        
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
  1216
        files = os.listdir(library_path)
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
  1217
        for file in files:
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
  1218
            filepath = os.path.join(library_path, file)
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
  1219
            if os.path.isfile(filepath) and os.path.splitext(filepath)[-1] == ".xml":
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
  1220
                xmlfile = open(filepath, 'r')
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
  1221
                xml_tree = minidom.parse(xmlfile)
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
  1222
                xmlfile.close()
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
  1223
                
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
  1224
                modules_infos = None
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
  1225
                for child in xml_tree.childNodes:
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
  1226
                    if child.nodeType == xml_tree.ELEMENT_NODE and child.nodeName == "EtherCATInfo":
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
  1227
                        modules_infos = EtherCATInfoClasses["EtherCATInfo.xsd"]["EtherCATInfo"]()
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
  1228
                        modules_infos.loadXMLTree(child, ["xmlns:xsi", "xsi:noNamespaceSchemaLocation"])
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
  1229
                
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
  1230
                if modules_infos is not None:
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
  1231
                    vendor = modules_infos.getVendor()
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
  1232
                    
2031
c6f32810723e Fix some issues regarding arbitrary variable mapping
laurent
parents: 2030
diff changeset
  1233
                    vendor_category = self.ModulesLibrary.setdefault(ExtractHexDecValue(vendor.getId()), 
c6f32810723e Fix some issues regarding arbitrary variable mapping
laurent
parents: 2030
diff changeset
  1234
                                                                     {"name": ExtractName(vendor.getName(), _("Miscellaneous")), 
c6f32810723e Fix some issues regarding arbitrary variable mapping
laurent
parents: 2030
diff changeset
  1235
                                                                      "groups": {}})
2022
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
  1236
                    
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
  1237
                    for group in modules_infos.getDescriptions().getGroups().getGroup():
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
  1238
                        group_type = group.getType()
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
  1239
                        
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
  1240
                        vendor_category["groups"].setdefault(group_type, {"name": ExtractName(group.getName(), group_type), 
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
  1241
                                                                          "parent": group.getParentGroup(),
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
  1242
                                                                          "order": group.getSortOrder(), 
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
  1243
                                                                          "devices": []})
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
  1244
                    
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
  1245
                    for device in modules_infos.getDescriptions().getDevices().getDevice():
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
  1246
                        device_group = device.getGroupType()
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
  1247
                        if not vendor_category["groups"].has_key(device_group):
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
  1248
                            raise ValueError, "Not such group \"%\"" % device_group
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
  1249
                        vendor_category["groups"][device_group]["devices"].append((device.getType().getcontent(), device))
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
  1250
    
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
  1251
    def GetModulesLibrary(self):
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
  1252
        library = []
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
  1253
        children_dict = {}
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
  1254
        for vendor_id, vendor in self.ModulesLibrary.iteritems():
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
  1255
            groups = []
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
  1256
            library.append({"name": vendor["name"],
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
  1257
                            "type": ETHERCAT_VENDOR,
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
  1258
                            "children": groups})
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
  1259
            for group_type, group in vendor["groups"].iteritems():
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
  1260
                group_infos = {"name": group["name"],
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
  1261
                               "order": group["order"],
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
  1262
                               "type": ETHERCAT_GROUP,
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
  1263
                               "children": children_dict.setdefault(group_type, [])}
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
  1264
                if group["parent"] is not None:
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
  1265
                    parent_children = children_dict.setdefault(group["parent"], [])
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
  1266
                    parent_children.append(group_infos)
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
  1267
                else:
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
  1268
                    groups.append(group_infos)
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
  1269
                device_dict = {}
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
  1270
                for device_type, device in group["devices"]:
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
  1271
                    device_infos = {"name": ExtractName(device.getName()),
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
  1272
                                    "type": ETHERCAT_DEVICE,
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
  1273
                                    "infos": {"device_type": device_type,
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
  1274
                                              "vendor": vendor_id,
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
  1275
                                              "product_code": device.getType().getProductCode(),
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
  1276
                                              "revision_number": device.getType().getRevisionNo()}}
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
  1277
                    group_infos["children"].append(device_infos)
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
  1278
                    device_type_occurrences = device_dict.setdefault(device_type, [])
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
  1279
                    device_type_occurrences.append(device_infos)
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
  1280
                for device_type_occurrences in device_dict.itervalues():
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
  1281
                    if len(device_type_occurrences) > 1:
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
  1282
                        for occurrence in device_type_occurrences:
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
  1283
                            occurrence["name"] += _(" (rev. %s)") % occurrence["infos"]["revision_number"]
2031
c6f32810723e Fix some issues regarding arbitrary variable mapping
laurent
parents: 2030
diff changeset
  1284
        library.sort(lambda x, y: cmp(x["name"], y["name"]))
2022
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
  1285
        return library
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
  1286
    
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
  1287
    def GetModuleInfos(self, type_infos):
2031
c6f32810723e Fix some issues regarding arbitrary variable mapping
laurent
parents: 2030
diff changeset
  1288
        vendor = self.ModulesLibrary.get(ExtractHexDecValue(type_infos["vendor"]), None)
2022
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
  1289
        if vendor is not None:
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
  1290
            for group_name, group in vendor["groups"].iteritems():
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
  1291
                for device_type, device in group["devices"]:
2029
7c848efa21c6 Adding support for displaying slave sync managers and profile object dictionary and for arbitrarily mapping variable through variable location
laurent
parents: 2026
diff changeset
  1292
                    product_code = ExtractHexDecValue(device.getType().getProductCode())
7c848efa21c6 Adding support for displaying slave sync managers and profile object dictionary and for arbitrarily mapping variable through variable location
laurent
parents: 2026
diff changeset
  1293
                    revision_number = ExtractHexDecValue(device.getType().getRevisionNo())
2022
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
  1294
                    if (device_type == type_infos["device_type"] and
2029
7c848efa21c6 Adding support for displaying slave sync managers and profile object dictionary and for arbitrarily mapping variable through variable location
laurent
parents: 2026
diff changeset
  1295
                        product_code == ExtractHexDecValue(type_infos["product_code"]) and
7c848efa21c6 Adding support for displaying slave sync managers and profile object dictionary and for arbitrarily mapping variable through variable location
laurent
parents: 2026
diff changeset
  1296
                        revision_number == ExtractHexDecValue(type_infos["revision_number"])):
2022
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
  1297
                        return device
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
  1298
        return None
c2295d311402 First working implementation of Beremiz plugin for etherlab
laurent
parents:
diff changeset
  1299
    
2032
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
  1300
    def GetModulesByProfile(self, profile_type):
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
  1301
        modules = []
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
  1302
        for vendor_id, vendor in self.ModulesLibrary.iteritems():
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
  1303
            for group_type, group in vendor["groups"].iteritems():
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
  1304
                for device_type, device in group["devices"]:
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
  1305
                    if profile_type in device.GetProfileNumbers():
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
  1306
                        product_code = ExtractHexDecValue(device.getType().getProductCode())
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
  1307
                        revision_number = ExtractHexDecValue(device.getType().getRevisionNo())
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
  1308
                        modules.append((device_type, vendor_id, product_code, revision_number))
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
  1309
        return modules
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
  1310
766078d83e22 Adding support for DS402 node subplugin (only simple state transition implemented)
laurent
parents: 2031
diff changeset
  1311