9 from POULibrary import POULibrary

     8 

    12 from ConfigEditor import NodeEditor, CIA402NodeEditor, MasterEditor, LibraryEditor, ETHERCAT_VENDOR, ETHERCAT_GROUP, ETHERCAT_DEVICE

    11 

    13 from dialogs import BrowseValuesLibraryDialog

    12 from EthercatSlave import ExtractHexDecValue, ExtractName

    14 from IDEFrame import TITLE, FILEMENU, PROJECTTREE

    13 from EthercatMaster import _EthercatCTN

    15 

    14 from ConfigEditor import LibraryEditor, ETHERCAT_VENDOR, ETHERCAT_GROUP, ETHERCAT_DEVICE

    16 try:

    17     from MotionLibrary import Headers, AxisXSD

    18     HAS_MCL = True

    19 except:

    20     HAS_MCL = False

    21 

    22 TYPECONVERSION = {"BOOL" : "X", "SINT" : "B", "INT" : "W", "DINT" : "D", "LINT" : "L",

    23     "USINT" : "B", "UINT" : "W", "UDINT" : "D", "ULINT" : "L", 

    24     "BYTE" : "B", "WORD" : "W", "DWORD" : "D", "LWORD" : "L"}

    25 

    26 DATATYPECONVERSION = {"BOOL" : "BIT", "SINT" : "S8", "INT" : "S16", "DINT" : "S32", "LINT" : "S64",

    27     "USINT" : "U8", "UINT" : "U16", "UDINT" : "U32", "ULINT" : "U64", 

    28     "BYTE" : "U8", "WORD" : "U16", "DWORD" : "U32", "LWORD" : "U64"}

    29 

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

    31 

    32 #--------------------------------------------------

    33 #         Remote Exec Etherlab Commands

    34 #--------------------------------------------------

    35 

    36 SCAN_COMMAND = """

    37 import commands

    38 result = commands.getoutput("ethercat slaves")

    39 slaves = []

    40 for slave_line in result.splitlines():

    41     chunks = slave_line.split()

    42     idx, pos, state, flag = chunks[:4]

    43     name = " ".join(chunks[4:])

    44     alias, position = pos.split(":")

    45     slave = {"idx": int(idx),

    46              "alias": int(alias),

    47              "position": int(position),

    48              "name": name}

    49     details = commands.getoutput("ethercat slaves -p %d -v" % slave["idx"])

    50     for details_line in details.splitlines():

    51         details_line = details_line.strip()

    52         for header, param in [("Vendor Id:", "vendor_id"),

    53                               ("Product code:", "product_code"),

    54                               ("Revision number:", "revision_number")]:

    55             if details_line.startswith(header):

    56                 slave[param] = details_line.split()[-1]

    57                 break

    58     slaves.append(slave)

    59 returnVal = slaves

    60 """

    61 

    62 #--------------------------------------------------

    63 #      Etherlab Specific Blocks Library

    64 #--------------------------------------------------

    65 

    66 def GetLocalPath(filename):

    67     return os.path.join(os.path.split(__file__)[0], filename)

    68 

    69 class EtherlabLibrary(POULibrary):

    70     def GetLibraryPath(self):

    71         return GetLocalPath("pous.xml")

    72 

    73     def Generate_C(self, buildpath, varlist, IECCFLAGS):

    74         etherlab_ext_file = open(GetLocalPath("etherlab_ext.c"), 'r')

    75         etherlab_ext_code = etherlab_ext_file.read()

    76         etherlab_ext_file.close()

    77         

    78         Gen_etherlabfile_path = os.path.join(buildpath, "etherlab_ext.c")

    79         ethelabfile = open(Gen_etherlabfile_path,'w')

    80         ethelabfile.write(etherlab_ext_code)

    81         ethelabfile.close()

    82         

    83         runtimefile_path = os.path.join(os.path.split(__file__)[0], "runtime_etherlab.py")

    84         return ((["etherlab_ext"], [(Gen_etherlabfile_path, IECCFLAGS)], True), "", 

    85                 ("runtime_etherlab.py", file(GetLocalPath("runtime_etherlab.py"))))

    86 

    87 #--------------------------------------------------

    88 #                    Ethercat Node

    89 #--------------------------------------------------

    90 

    91 class _EthercatSlaveCTN:

    92     

    93     NODE_PROFILE = None

    94     EditorType = NodeEditor

    95     

    96     def GetIconName(self):

    97         return "Slave"

    98     

    99     def ExtractHexDecValue(self, value):

   100         return ExtractHexDecValue(value)

   101     

   102     def GetSizeOfType(self, type):

   103         return TYPECONVERSION.get(self.GetCTRoot().GetBaseType(type), None)

   104     

   105     def GetSlavePos(self):

   106         return self.BaseParams.getIEC_Channel()

   107     

   108     def GetParamsAttributes(self, path = None):

   109         if path:

   110             parts = path.split(".", 1)

   111             if self.MandatoryParams and parts[0] == self.MandatoryParams[0]:

   112                 return self.MandatoryParams[1].getElementInfos(parts[0], parts[1])

   113             elif self.CTNParams and parts[0] == self.CTNParams[0]:

   114                 return self.CTNParams[1].getElementInfos(parts[0], parts[1])

   115         else:

   116             params = []

   117             if self.CTNParams:

   118                 params.append(self.CTNParams[1].getElementInfos(self.CTNParams[0]))

   119             else:

   120                 params.append({

   121                     'use': 'required', 

   122                     'type': 'element', 

   123                     'name': 'SlaveParams', 

   124                     'value': None, 

   125                     'children': []

   126                 })

   127             

   128             slave_type = self.CTNParent.GetSlaveType(self.GetSlavePos())

   129             params[0]['children'].insert(0,

   130                    {'use': 'optional', 

   131                     'type': self.CTNParent.GetSlaveTypesLibrary(self.NODE_PROFILE), 

   132                     'name': 'Type', 

   133                     'value': (slave_type["device_type"], slave_type)}) 

   134             params[0]['children'].insert(1,

   135                    {'use': 'optional', 

   136                     'type': 'unsignedLong', 

   137                     'name': 'Alias', 

   138                     'value': self.CTNParent.GetSlaveAlias(self.GetSlavePos())})

   139             return params

   140         

   141     def SetParamsAttribute(self, path, value):

   142         position = self.BaseParams.getIEC_Channel()

   143         

   144         if path == "SlaveParams.Type":

   145             self.CTNParent.SetSlaveType(position, value)

   146             slave_type = self.CTNParent.GetSlaveType(self.GetSlavePos())

   147             value = (slave_type["device_type"], slave_type)

   148             if self._View is not None:

   149                 wx.CallAfter(self._View.RefreshSlaveInfos)

   150             return value, True

   151         elif path == "SlaveParams.Alias":

   152             self.CTNParent.SetSlaveAlias(position, value)

   153             return value, True

   154         

   155         value, refresh = ConfigTreeNode.SetParamsAttribute(self, path, value)

   156         

   157         # Filter IEC_Channel, Slave_Type and Alias that have specific behavior

   158         if path == "BaseParams.IEC_Channel" and value != position:

   159             self.CTNParent.SetSlavePosition(position, value)

   160         

   161         return value, refresh

   162         

   163     def GetSlaveInfos(self):

   164         return self.CTNParent.GetSlaveInfos(self.GetSlavePos())

   165     

   166     def GetSlaveVariables(self, limits):

   167         return self.CTNParent.GetSlaveVariables(self.GetSlavePos(), limits)

   168     

   169     def GetVariableLocationTree(self):

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

   171                  "type": LOCATION_CONFNODE,

   172                  "location": self.GetFullIEC_Channel(),

   173                  "children": self.CTNParent.GetDeviceLocationTree(self.GetSlavePos(), self.GetCurrentLocation(), self.BaseParams.getName())

   174         }

   175 

   176     def CTNGenerate_C(self, buildpath, locations):

   177         return [],"",False

   178 

   179 #--------------------------------------------------

   180 #                 Ethercat CIA402 Node

   181 #--------------------------------------------------

   182 

   183 if HAS_MCL:

   184     

   185     NODE_VARIABLES = [

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

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

   188         ("ModesOfOperation", 0x06060, 0x00, "SINT", "Q"),

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

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

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

   192         ("ActualVelocity", 0x606C, 0x00, "DINT", "I"),

   193     ]

   194     

   195     DEFAULT_RETRIEVE = "    __CIA402Node_%(location)s.axis->%(name)s = *(__CIA402Node_%(location)s.%(name)s);"

   196     DEFAULT_PUBLISH = "    *(__CIA402Node_%(location)s.%(name)s) = __CIA402Node_%(location)s.axis->%(name)s;"

   197     

   198     EXTRA_NODE_VARIABLES = [

   199         ("ErrorCode", [

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

   201              "publish": None}

   202             ]),

   203         ("DigitalInputs", [

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

   205              "publish": None}

   206             ]),

   207         ("DigitalOutputs", [

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

   209              "retrieve": None}

   210             ])

   211     ]

   212     EXTRA_NODE_VARIABLES_DICT = dict([("Enable" + name, value) for name, value in EXTRA_NODE_VARIABLES])

   213 

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

   215     BLOCK_OUTPUT_TEMPLATE = "    __SET_VAR(data__->,%(output_name)s, __GET_VAR(%(blockname)s->%(output_name)s));"

   216     

   217     BLOCK_FUNCTION_TEMPLATE = """

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

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

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

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

   222 %(extract_inputs)s

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

   224 %(return_outputs)s

   225 }

   226 """

   227     

   228     BLOCK_FUNTION_DEFINITION_TEMPLATE = """    if (!__CIA402Node_%(location)s.axis->__mcl_func_MC_%(blocktype)s)

   229     __CIA402Node_%(location)s.axis->__mcl_func_MC_%(blocktype)s = __%(blocktype)s_%(location)s;"""

   230     

   231     GLOBAL_INSTANCES = [

   232         {"blocktype": "GetTorqueLimit", 

   233          "inputs": [],

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

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

   236         {"blocktype": "SetTorqueLimit", 

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

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

   239          "outputs": []},

   240     ]

   241     

   242     class _EthercatCIA402SlaveCTN(_EthercatSlaveCTN):

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

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

   245           <xsd:element name="CIA402SlaveParams">

   246             <xsd:complexType>

   247               %s

   248             </xsd:complexType>

   249           </xsd:element>

   250         </xsd:schema>

   251         """ % ("\n".join(['<xsd:attribute name="Enable%s" type="xsd:boolean" use="optional" default="false"/>' % category 

   252                           for category, variables in EXTRA_NODE_VARIABLES]) + AxisXSD)

   253         

   254         NODE_PROFILE = 402

   255         EditorType = CIA402NodeEditor

   256         

   257         ConfNodeMethods = [

   258             {"bitmap" : "CIA402AxisRef",

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

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

   261              "method" : "_getCIA402AxisRef",

   262              "push": True},

   263         ]

   264         

   265         def GetIconName(self):

   266             return "CIA402Slave"

   267         

   268         def SetParamsAttribute(self, path, value):

   269             if path == "CIA402SlaveParams.Type":

   270                 path = "SlaveParams.Type"

   271             elif path == "CIA402SlaveParams.Alias":

   272                 path = "SlaveParams.Alias"

   273             return _EthercatSlaveCTN.SetParamsAttribute(self, path, value)

   274         

   275         def GetVariableLocationTree(self):

   276             axis_name = self.CTNName()

   277             current_location = self.GetCurrentLocation()

   278             children = [{"name": "%s Axis Ref" % (axis_name),

   279                          "type": LOCATION_VAR_INPUT,

   280                          "size": "W",

   281                          "IEC_type": "AXIS_REF",

   282                          "var_name": axis_name,

   283                          "location": "%%IW%s.0" % (".".join(map(str, current_location))),

   284                          "description": "",

   285                          "children": []}]

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

   287             return  {"name": axis_name,

   288                      "type": LOCATION_CONFNODE,

   289                      "location": self.GetFullIEC_Channel(),

   290                      "children": children,

   291             }

   292         

   293         def CTNGlobalInstances(self):

   294             current_location = self.GetCurrentLocation()

   295             return [("%s_%s" % (block_infos["blocktype"], "_".join(map(str, current_location))),

   296                      "EtherLab%s" % block_infos["blocktype"]) for block_infos in GLOBAL_INSTANCES]

   297         

   298         def _getCIA402AxisRef(self):

   299             data = wx.TextDataObject(str(("%%IW%s.0" % ".".join(map(str, self.GetCurrentLocation())), 

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

   301             dragSource = wx.DropSource(self.GetCTRoot().AppFrame)

   302             dragSource.SetData(data)

   303             dragSource.DoDragDrop()

   304         

   305         def CTNGenerate_C(self, buildpath, locations):

   306             current_location = self.GetCurrentLocation()

   307             

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

   309             

   310             plc_cia402node_filepath = os.path.join(os.path.split(__file__)[0], "plc_cia402node.c")

   311             plc_cia402node_file = open(plc_cia402node_filepath, 'r')

   312             plc_cia402node_code = plc_cia402node_file.read()

   313             plc_cia402node_file.close()

   314             

   315             str_completion = {

   316                 "slave_pos": self.GetSlavePos(),

   317                 "location": location_str,

   318                 "MCL_headers": Headers,

   319                 "extern_located_variables_declaration": [],

   320                 "fieldbus_interface_declaration": [],

   321                 "fieldbus_interface_definition": [],

   322                 "entry_variables": [],

   323                 "init_axis_params": [],

   324                 "init_entry_variables": [],

   325                 "extra_variables_retrieve": [],

   326                 "extra_variables_publish": []

   327             }

   328             

   329             for blocktype_infos in GLOBAL_INSTANCES:

   330                 texts = {

   331                     "blocktype": blocktype_infos["blocktype"],

   332                     "ucase_blocktype": blocktype_infos["blocktype"].upper(),

   333                     "location": "_".join(map(str, current_location))

   334                 }

   335                 texts["blockname"] = "%(ucase_blocktype)s_%(location)s" % texts

   336                 

   337                 inputs = [{"input_name": "POS", "input_value": str(self.GetSlavePos())},

   338                           {"input_name": "EXECUTE", "input_value": "__GET_VAR(data__->EXECUTE)"}] +\

   339                          [{"input_name": input["name"].upper(), 

   340                            "input_value": "__GET_VAR(data__->%s)" % input["name"].upper()}

   341                           for input in blocktype_infos["inputs"]]

   342                 input_texts = []

   343                 for input_infos in inputs:

   344                     input_infos.update(texts)

   345                     input_texts.append(BLOCK_INPUT_TEMPLATE % input_infos)

   346                 texts["extract_inputs"] = "\n".join(input_texts)

   347                 

   348                 outputs = [{"output_name": output} for output in ["DONE", "BUSY", "ERROR"]] + \

   349                           [{"output_name": output["name"].upper()} for output in blocktype_infos["outputs"]]

   350                 output_texts = []

   351                 for output_infos in outputs:

   352                     output_infos.update(texts)

   353                     output_texts.append(BLOCK_OUTPUT_TEMPLATE % output_infos)

   354                 texts["return_outputs"] = "\n".join(output_texts)

   355                 

   356                 str_completion["fieldbus_interface_declaration"].append(

   357                         BLOCK_FUNCTION_TEMPLATE % texts)

   358                 

   359                 str_completion["fieldbus_interface_definition"].append(

   360                         BLOCK_FUNTION_DEFINITION_TEMPLATE % texts)

   361                 

   362             variables = NODE_VARIABLES[:]

   363             

   364             params = self.CTNParams[1].getElementInfos(self.CTNParams[0])

   365             for param in params["children"]:

   366                 if param["name"] in EXTRA_NODE_VARIABLES_DICT:

   367                     if param["value"]:

   368                         extra_variables = EXTRA_NODE_VARIABLES_DICT.get(param["name"])

   369                         for variable_infos in extra_variables:

   370                             var_infos = {

   371                                 "location": location_str,

   372                                 "name": variable_infos["description"][0]

   373                             }

   374                             variables.append(variable_infos["description"])

   375                             retrieve_template = variable_infos.get("retrieve", DEFAULT_RETRIEVE)

   376                             publish_template = variable_infos.get("publish", DEFAULT_PUBLISH)

   377                             

   378                             if retrieve_template is not None:

   379                                 str_completion["extra_variables_retrieve"].append(

   380                                     retrieve_template % var_infos)

   381                             if publish_template is not None:

   382                                 str_completion["extra_variables_publish"].append(

   383                                     publish_template % var_infos)

   384                 elif param["value"] is not None:

   385                     param_infos = {

   386                         "location": location_str,

   387                         "param_name": param["name"],

   388                     }

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

   390                         param_infos["param_value"] = {True: "true", False: "false"}[param["value"]]

   391                     else:

   392                         param_infos["param_value"] = str(param["value"])

   393                     str_completion["init_axis_params"].append(

   394                         "        __CIA402Node_%(location)s.axis->%(param_name)s = %(param_value)s;" % param_infos)

   395             

   396             for variable in variables:

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

   398                 var_infos["location"] = location_str

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

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

   401                 

   402                 str_completion["extern_located_variables_declaration"].append(

   403                         "IEC_%(var_type)s *%(var_name)s;" % var_infos)

   404                 str_completion["entry_variables"].append(

   405                         "    IEC_%(var_type)s *%(name)s;" % var_infos)

   406                 str_completion["init_entry_variables"].append(

   407                         "    __CIA402Node_%(location)s.%(name)s = %(var_name)s;" % var_infos)

   408                 

   409                 self.CTNParent.FileGenerator.DeclareVariable(

   410                         self.GetSlavePos(), var_infos["index"], var_infos["subindex"], 

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

   412             

   413             for element in ["extern_located_variables_declaration", 

   414                             "fieldbus_interface_declaration",

   415                             "fieldbus_interface_definition",

   416                             "entry_variables", 

   417                             "init_axis_params", 

   418                             "init_entry_variables",

   419                             "extra_variables_retrieve",

   420                             "extra_variables_publish"]:

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

   422             

   423             Gen_CIA402Nodefile_path = os.path.join(buildpath, "cia402node_%s.c"%location_str)

   424             cia402nodefile = open(Gen_CIA402Nodefile_path, 'w')

   425             cia402nodefile.write(plc_cia402node_code % str_completion)

   426             cia402nodefile.close()

   427             

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

   429 

   430 #--------------------------------------------------

   431 #                 Ethercat MASTER

   432 #--------------------------------------------------

   433 

   434 EtherCATConfigClasses = GenerateClassesFromXSD(os.path.join(os.path.dirname(__file__), "EtherCATConfig.xsd")) 

   435 

   436 def ExtractHexDecValue(value):

   437     try:

   438         return int(value)

   439     except:

   440         pass

   441     try:

   442         return int(value.replace("#", "0"), 16)

   443     except:

   444         raise ValueError, "Invalid value for HexDecValue \"%s\"" % value

   445 

   446 def GenerateHexDecValue(value, base=10):

   447     if base == 10:

   448         return str(value)

   449     elif base == 16:

   450         return "#x%.8x" % value

   451     else:

   452         raise ValueError, "Not supported base"

   453 

   454 def sort_commands(x, y):

   455     if x["Index"] == y["Index"]:

   456         return cmp(x["Subindex"], y["Subindex"])

   457     return cmp(x["Index"], y["Index"])

   458 

   459 cls = EtherCATConfigClasses.get("Config_Slave", None)

   460 if cls:

   461     

   462     def getType(self):

   463         slave_info = self.getInfo()

   464         return {"device_type": slave_info.getName(),

   465                 "vendor": GenerateHexDecValue(slave_info.getVendorId()),

   466                 "product_code": GenerateHexDecValue(slave_info.getProductCode(), 16),

   467                 "revision_number": GenerateHexDecValue(slave_info.getRevisionNo(), 16)}

   468     setattr(cls, "getType", getType)

   469 

   470     def setType(self, type_infos):

   471         slave_info = self.getInfo()

   472         slave_info.setName(type_infos["device_type"])

   473         slave_info.setVendorId(ExtractHexDecValue(type_infos["vendor"]))

   474         slave_info.setProductCode(ExtractHexDecValue(type_infos["product_code"]))

   475         slave_info.setRevisionNo(ExtractHexDecValue(type_infos["revision_number"]))

   476     setattr(cls, "setType", setType)

   477     

   478     def getInitCmds(self, create_default=False):

   479         Mailbox = self.getMailbox()

   480         if Mailbox is None:

   481             if create_default:

   482                 self.addMailbox()

   483                 Mailbox = self.getMailbox()

   484             else:

   485                 return None

   486         CoE = Mailbox.getCoE()

   487         if CoE is None:

   488             if create_default:

   489                 Mailbox.addCoE()

   490                 CoE = Mailbox.getCoE()

   491             else:

   492                 return None

   493         InitCmds = CoE.getInitCmds()

   494         if InitCmds is None and create_default:

   495             CoE.addInitCmds()

   496             InitCmds = CoE.getInitCmds()

   497         return InitCmds

   498     setattr(cls, "getInitCmds", getInitCmds)

   499     

   500     def getStartupCommands(self):

   501         pos = self.getInfo().getPhysAddr()

   502         InitCmds = self.getInitCmds()

   503         if InitCmds is None:

   504             return []

   505         commands = []

   506         for idx, InitCmd in enumerate(InitCmds.getInitCmd()):

   507             comment = InitCmd.getComment()

   508             if comment is None:

   509                 comment = ""

   510             commands.append({

   511                 "command_idx": idx,

   512                 "Position": pos,

   513                 "Index": InitCmd.getIndex(),

   514                 "Subindex": InitCmd.getSubIndex(),

   515                 "Value": InitCmd.getData(),

   516                 "Description": comment})

   517         commands.sort(sort_commands)

   518         return commands

   519     setattr(cls, "getStartupCommands", getStartupCommands)

   520     

   521     def appendStartupCommand(self, command_infos):

   522         InitCmds = self.getInitCmds(True)

   523         command = EtherCATConfigClasses["InitCmds_InitCmd"]()

   524         command.setIndex(command_infos["Index"])

   525         command.setSubIndex(command_infos["Subindex"])

   526         command.setData(command_infos["Value"])

   527         command.setComment(command_infos["Description"])

   528         InitCmds.appendInitCmd(command)

   529         return len(InitCmds.getInitCmd()) - 1

   530     setattr(cls, "appendStartupCommand", appendStartupCommand)

   531     

   532     def setStartupCommand(self, command_infos):

   533         InitCmds = self.getInitCmds()

   534         if InitCmds is not None:

   535             commands = InitCmds.getInitCmd()

   536             if command_infos["command_idx"] < len(commands):

   537                 command = commands[command_infos["command_idx"]]

   538                 command.setIndex(command_infos["Index"])

   539                 command.setSubIndex(command_infos["Subindex"])

   540                 command.setData(command_infos["Value"])

   541                 command.setComment(command_infos["Description"])

   542     setattr(cls, "setStartupCommand", setStartupCommand)

   543     

   544     def removeStartupCommand(self, command_idx):

   545         InitCmds = self.getInitCmds()

   546         if InitCmds is not None:

   547             if command_idx < len(InitCmds.getInitCmd()):

   548                 InitCmds.removeInitCmd(command_idx)

   549     setattr(cls, "removeStartupCommand", removeStartupCommand)

   550 

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

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

   553       <xsd:element name="ProcessVariables">

   554         <xsd:complexType>

   555           <xsd:sequence>

   556             <xsd:element name="variable" minOccurs="0" maxOccurs="unbounded">

   557               <xsd:complexType>

   558                 <xsd:sequence>

   559                   <xsd:element name="ReadFrom" type="LocationDesc" minOccurs="0"/>

   560                   <xsd:element name="WriteTo" type="LocationDesc" minOccurs="0"/>

   561                 </xsd:sequence>

   562                 <xsd:attribute name="Name" type="xsd:string" use="required"/>

   563                 <xsd:attribute name="Comment" type="xsd:string" use="required"/>

   564               </xsd:complexType>

   565             </xsd:element>

   566           </xsd:sequence>

   567         </xsd:complexType>

   568       </xsd:element>

   569       <xsd:complexType name="LocationDesc">

   570         <xsd:attribute name="Position" type="xsd:integer" use="required"/>

   571         <xsd:attribute name="Index" type="xsd:integer" use="required"/>

   572         <xsd:attribute name="SubIndex" type="xsd:integer" use="required"/>

   573       </xsd:complexType>

   574     </xsd:schema>

   575 """

   576 

   577 ProcessVariablesClasses = GenerateClassesFromXSDstring(ProcessVariablesXSD) 

   578 

   579 class _EthercatCTN:

   580     

   581     CTNChildrenTypes = [("EthercatSlave", _EthercatSlaveCTN, "Ethercat Slave")]

   582     if HAS_MCL:

   583         CTNChildrenTypes.append(("EthercatCIA402Slave", _EthercatCIA402SlaveCTN, "Ethercat CIA402 Slave"))

   584     EditorType = MasterEditor

   585     

   586     def __init__(self):

   587         config_filepath = self.ConfigFileName()

   588         config_is_saved = False

   589         self.Config = EtherCATConfigClasses["EtherCATConfig"]()

   590         if os.path.isfile(config_filepath):

   591             config_xmlfile = open(config_filepath, 'r')

   592             config_tree = minidom.parse(config_xmlfile)

   593             config_xmlfile.close()

   594             

   595             for child in config_tree.childNodes:

   596                 if child.nodeType == config_tree.ELEMENT_NODE and child.nodeName == "EtherCATConfig":

   597                     self.Config.loadXMLTree(child)

   598                     config_is_saved = True

   599         

   600         process_filepath = self.ProcessVariablesFileName()

   601         process_is_saved = False

   602         self.ProcessVariables = ProcessVariablesClasses["ProcessVariables"]()

   603         if os.path.isfile(process_filepath):

   604             process_xmlfile = open(process_filepath, 'r')

   605             process_tree = minidom.parse(process_xmlfile)

   606             process_xmlfile.close()

   607             

   608             for child in process_tree.childNodes:

   609                 if child.nodeType == process_tree.ELEMENT_NODE and child.nodeName == "ProcessVariables":

   610                     self.ProcessVariables.loadXMLTree(child)

   611                     process_is_saved = True

   612         

   613         if config_is_saved and process_is_saved:

   614             self.CreateBuffer(True)

   615         else:

   616             self.CreateBuffer(False)

   617             self.OnCTNSave()

   618     

   619     def GetContextualMenuItems(self):

   620         return [("Add Ethercat Slave", "Add Ethercat Slave to Master", self.OnAddEthercatSlave)]

   621     

   622     def OnAddEthercatSlave(self, event):

   623         app_frame = self.GetCTRoot().AppFrame

   624         dialog = BrowseValuesLibraryDialog(app_frame, 

   625             "Ethercat Slave Type", self.GetSlaveTypesLibrary())

   626         if dialog.ShowModal() == wx.ID_OK:

   627             type_infos = dialog.GetValueInfos()

   628             device, alignment = self.GetModuleInfos(type_infos)

   629             if device is not None:

   630                 if HAS_MCL and _EthercatCIA402SlaveCTN.NODE_PROFILE in device.GetProfileNumbers():

   631                     ConfNodeType = "EthercatCIA402Slave"

   632                 else:

   633                     ConfNodeType = "EthercatSlave"

   634                 new_child = self.CTNAddChild("%s_0" % ConfNodeType, ConfNodeType)

   635                 new_child.SetParamsAttribute("SlaveParams.Type", type_infos)

   636                 self.CTNRequestSave()

   637                 new_child._OpenView()

   638                 app_frame._Refresh(TITLE, FILEMENU, PROJECTTREE)

   639         dialog.Destroy()

   640     

   641     def ExtractHexDecValue(self, value):

   642         return ExtractHexDecValue(value)

   643 

   644     def GetSizeOfType(self, type):

   645         return TYPECONVERSION.get(self.GetCTRoot().GetBaseType(type), None)

   646 

   647     def ConfigFileName(self):

   648         return os.path.join(self.CTNPath(), "config.xml")

   649     

   650     def ProcessVariablesFileName(self):

   651         return os.path.join(self.CTNPath(), "process_variables.xml")

   652     

   653     def FilterSlave(self, slave, vendor=None, slave_pos=None, slave_profile=None):

   654         if slave_pos is not None and slave.getInfo().getPhysAddr() != slave_pos:

   655             return False

   656         type_infos = slave.getType()

   657         if vendor is not None and ExtractHexDecValue(type_infos["vendor"]) != vendor:

   658             return False

   659         device, alignment = self.GetModuleInfos(type_infos)

   660         if slave_profile is not None and slave_profile not in device.GetProfileNumbers():

   661             return False

   662         return True

   663 

   664     def GetSlaves(self, vendor=None, slave_pos=None, slave_profile=None):

   665         slaves = []

   666         for slave in self.Config.getConfig().getSlave():

   667             if self.FilterSlave(slave, vendor, slave_pos, slave_profile):

   668                 slaves.append(slave.getInfo().getPhysAddr())

   669         slaves.sort()

   670         return slaves

   671 

   672     def GetSlave(self, slave_pos):

   673         for slave in self.Config.getConfig().getSlave():

   674             slave_info = slave.getInfo()

   675             if slave_info.getPhysAddr() == slave_pos:

   676                 return slave

   677         return None

   678 

   679     def GetStartupCommands(self, vendor=None, slave_pos=None, slave_profile=None):

   680         commands = []

   681         for slave in self.Config.getConfig().getSlave():

   682             if self.FilterSlave(slave, vendor, slave_pos, slave_profile):

   683                 commands.append((slave.getInfo().getPhysAddr(), slave.getStartupCommands()))

   684         commands.sort()

   685         return reduce(lambda x, y: x + y[1], commands, [])

   686     

   687     def AppendStartupCommand(self, command_infos):

   688         slave = self.GetSlave(command_infos["Position"])

   689         if slave is not None:

   690             command_idx = slave.appendStartupCommand(command_infos)

   691             self.BufferModel()

   692             return command_idx

   693         return None

   694     

   695     def SetStartupCommandInfos(self, command_infos):

   696         slave = self.GetSlave(command_infos["Position"])

   697         if slave is not None:

   698             slave.setStartupCommand(command_infos)

   699             self.BufferModel()

   700     

   701     def RemoveStartupCommand(self, slave_pos, command_idx, buffer=True):

   702         slave = self.GetSlave(slave_pos)

   703         if slave is not None:

   704             slave.removeStartupCommand(command_idx)

   705             if buffer:

   706                 self.BufferModel()

   707     

   708     def SetProcessVariables(self, variables):

   709         vars = []

   710         for var in variables:

   711             variable = ProcessVariablesClasses["ProcessVariables_variable"]()

   712             variable.setName(var["Name"])

   713             variable.setComment(var["Description"])

   714             if var["ReadFrom"] != "":

   715                 position, index, subindex = var["ReadFrom"]

   716                 if variable.getReadFrom() is None:

   717                     variable.addReadFrom()

   718                 read_from = variable.getReadFrom()

   719                 read_from.setPosition(position)

   720                 read_from.setIndex(index)

   721                 read_from.setSubIndex(subindex)

   722             elif variable.getReadFrom() is not None:

   723                 variable.deleteReadFrom()

   724             if var["WriteTo"] != "":

   725                 position, index, subindex = var["WriteTo"]

   726                 if variable.getWriteTo() is None:

   727                     variable.addWriteTo()

   728                 write_to = variable.getWriteTo()

   729                 write_to.setPosition(position)

   730                 write_to.setIndex(index)

   731                 write_to.setSubIndex(subindex)

   732             elif variable.getWriteTo() is not None:

   733                 variable.deleteWriteTo()

   734             vars.append(variable)

   735         self.ProcessVariables.setvariable(vars)

   736         self.BufferModel()

   737         

   738     def GetProcessVariables(self):

   739         variables = []

   740         idx = 0

   741         for variable in self.ProcessVariables.getvariable():

   742             var = {"Name": variable.getName(),

   743                    "Number": idx,

   744                    "Description": variable.getComment()}

   745             read_from = variable.getReadFrom()

   746             if read_from is not None:

   747                 var["ReadFrom"] = (read_from.getPosition(),

   748                                    read_from.getIndex(),

   749                                    read_from.getSubIndex())

   750             else:

   751                 var["ReadFrom"] = ""

   752             write_to = variable.getWriteTo()

   753             if write_to is not None:

   754                 var["WriteTo"] = (write_to.getPosition(),

   755                                    write_to.getIndex(),

   756                                    write_to.getSubIndex())

   757             else:

   758                 var["WriteTo"] = ""

   759             variables.append(var)

   760             idx += 1

   761         return variables

   762     

   763     def _ScanNetwork(self):

   764         app_frame = self.GetCTRoot().AppFrame

   765         

   766         execute = True

   767         if len(self.Children) > 0:

   768             dialog = wx.MessageDialog(app_frame, 

   769                 _("The current network configuration will be deleted.\nDo you want to continue?"), 

   770                 _("Scan Network"), 

   771                 wx.YES_NO|wx.ICON_QUESTION)

   772             execute = dialog.ShowModal() == wx.ID_YES

   773             dialog.Destroy()

   774         

   775         if execute:

   776             error, returnVal = self.RemoteExec(SCAN_COMMAND, returnVal = None)

   777             if error != 0:

   778                 dialog = wx.MessageDialog(app_frame, returnVal, "Error", wx.OK|wx.ICON_ERROR)

   779                 dialog.ShowModal()

   780                 dialog.Destroy()

   781             elif returnVal is not None:

   782                 for child in self.IECSortedChildren():

   783                     self._doRemoveChild(child)

   784                 

   785                 for slave in returnVal:

   786                     type_infos = {

   787                         "vendor": slave["vendor_id"],

   788                         "product_code": slave["product_code"],

   789                         "revision_number":slave["revision_number"],

   790                     }

   791                     device, alignment = self.GetModuleInfos(type_infos)

   792                     if device is not None:

   793                         if HAS_MCL and _EthercatCIA402SlaveCTN.NODE_PROFILE in device.GetProfileNumbers():

   794                             CTNType = "EthercatCIA402Slave"

   795                         else:

   796                             CTNType = "EthercatSlave"

   797                         self.CTNAddChild("slave%s" % slave["idx"], CTNType, slave["idx"])

   798                         self.SetSlaveAlias(slave["idx"], slave["alias"])

   799                         type_infos["device_type"] = device.getType().getcontent()

   800                         self.SetSlaveType(slave["idx"], type_infos)

   801 

   802     def CTNAddChild(self, CTNName, CTNType, IEC_Channel=0):

   803         """

   804         Create the confnodes that may be added as child to this node self

   805         @param CTNType: string desining the confnode class name (get name from CTNChildrenTypes)

   806         @param CTNName: string for the name of the confnode instance

   807         """

   808         newConfNodeOpj = ConfigTreeNode.CTNAddChild(self, CTNName, CTNType, IEC_Channel)

   809         

   810         slave = self.GetSlave(newConfNodeOpj.BaseParams.getIEC_Channel())

   811         if slave is None:

   812             slave = EtherCATConfigClasses["Config_Slave"]()

   813             slave_infos = slave.getInfo()

   814             slave_infos.setName("undefined")

   815             slave_infos.setPhysAddr(newConfNodeOpj.BaseParams.getIEC_Channel())

   816             slave_infos.setAutoIncAddr(0)

   817             self.Config.getConfig().appendSlave(slave)

   818             self.BufferModel()

   819             self.OnCTNSave()

   820         

   821         return newConfNodeOpj

   822 

   823     def _doRemoveChild(self, CTNInstance):

   824         slave_pos = CTNInstance.GetSlavePos()

   825         config = self.Config.getConfig()

   826         for idx, slave in enumerate(config.getSlave()):

   827             slave_infos = slave.getInfo()

   828             if slave_infos.getPhysAddr() == slave_pos:

   829                 config.removeSlave(idx)

   830                 self.BufferModel()

   831                 self.OnCTNSave()

   832         ConfigTreeNode._doRemoveChild(self, CTNInstance)

   833 

   834     def SetSlavePosition(self, slave_pos, new_pos):

   835         slave = self.GetSlave(slave_pos)

   836         if slave is not None:

   837             slave_info = slave.getInfo()

   838             slave_info.setPhysAddr(new_pos)

   839             for variable in self.ProcessVariables.getvariable():

   840                 read_from = variable.getReadFrom()

   841                 if read_from is not None and read_from.getPosition() == slave_pos:

   842                     read_from.setPosition(new_pos)

   843                 write_to = variable.getWriteTo()

   844                 if write_to is not None and write_to.getPosition() == slave_pos:

   845                     write_to.setPosition(new_pos)

   846             self.CreateBuffer(True)

   847             self.OnCTNSave()

   848             if self._View is not None:

   849                 self._View.RefreshView()

   850                 self._View.RefreshBuffer()

   851     

   852     def GetSlaveAlias(self, slave_pos):

   853         slave = self.GetSlave(slave_pos)

   854         if slave is not None:

   855             slave_info = slave.getInfo()

   856             return slave_info.getAutoIncAddr()

   857         return None

   858     

   859     def SetSlaveAlias(self, slave_pos, alias):

   860         slave = self.GetSlave(slave_pos)

   861         if slave is not None:

   862             slave_info = slave.getInfo()

   863             slave_info.setAutoIncAddr(alias)

   864             self.BufferModel()

   865     

   866     def GetSlaveType(self, slave_pos):

   867         slave = self.GetSlave(slave_pos)

   868         if slave is not None:

   869             return slave.getType()

   870         return None

   871     

   872     def SetSlaveType(self, slave_pos, type_infos):

   873         slave = self.GetSlave(slave_pos)

   874         if slave is not None:

   875             slave.setType(type_infos)

   876             self.BufferModel()

   877     

   878     def GetSlaveInfos(self, slave_pos):

   879         slave = self.GetSlave(slave_pos)

   880         if slave is not None:

   881             type_infos = slave.getType()

   882             device, alignment = self.GetModuleInfos(type_infos)

   883             if device is not None:

   884                 infos = type_infos.copy()

   885                 infos.update({"physics": device.getPhysics(),

   886                               "sync_managers": device.GetSyncManagers(),

   887                               "entries": self.GetSlaveVariables(device)})

   888                 return infos

   889         return None

   890     

   891     def GetSlaveVariables(self, slave_pos=None, limits=None, device=None):

   892         if device is None and slave_pos is not None:

   893             slave = self.GetSlave(slave_pos)

   894             if slave is not None:

   895                 type_infos = slave.getType()

   896                 device, alignment = self.GetModuleInfos(type_infos)

   897         if device is not None:

   898             entries = device.GetEntriesList(limits)

   899             entries_list = entries.items()

   900             entries_list.sort()

   901             entries = []

   902             current_index = None

   903             current_entry = None

   904             for (index, subindex), entry in entries_list:

   905                 entry["children"] = []

   906                 if slave_pos is not None:

   907                     entry["Position"] = str(slave_pos)

   908                 entry

   909                 if index != current_index:

   910                     current_index = index

   911                     current_entry = entry

   912                     entries.append(entry)

   913                 elif current_entry is not None:

   914                     current_entry["children"].append(entry)

   915                 else:

   916                     entries.append(entry)

   917             return entries

   918         return []

   919     

   920     def GetSlaveVariableDataType(self, slave_pos, index, subindex):

   921         slave = self.GetSlave(slave_pos)

   922         if slave is not None:

   923             device, alignment = self.GetModuleInfos(slave.getType())

   924             if device is not None:

   925                 entries = device.GetEntriesList()

   926                 entry_infos = entries.get((index, subindex))

   927                 if entry_infos is not None:

   928                     return entry_infos["Type"]

   929         return None

   930     

   931     def GetNodesVariables(self, vendor=None, slave_pos=None, slave_profile=None, limits=None):

   932         entries = []

   933         for slave_position in self.GetSlaves():

   934             if slave_pos is not None and slave_position != slave_pos:

   935                 continue

   936             slave = self.GetSlave(slave_position)

   937             type_infos = slave.getType()

   938             if vendor is not None and ExtractHexDecValue(type_infos["vendor"]) != vendor:

   939                 continue

   940             device, alignment = self.GetModuleInfos(type_infos)

   941             if slave_profile is not None and slave_profile not in device.GetProfileNumbers():

   942                 continue

   943             entries.extend(self.GetSlaveVariables(slave_position, limits, device))

   944         return entries

   945      

   946     def GetModuleInfos(self, type_infos):

   947         return self.CTNParent.GetModuleInfos(type_infos)

   948     

   949     def GetSlaveTypesLibrary(self, profile_filter=None):

   950         return self.CTNParent.GetModulesLibrary(profile_filter)

   951     

   952     def GetLibraryVendors(self):

   953         return self.CTNParent.GetVendors()

   954     

   955     def GetDeviceLocationTree(self, slave_pos, current_location, device_name):

   956         slave = self.GetSlave(slave_pos)

   957         vars = []    

   958         if slave is not None:

   959             type_infos = slave.getType()

   960         

   961             device, alignment = self.GetModuleInfos(type_infos)

   962             if device is not None:

   963                 sync_managers = []

   964                 for sync_manager in device.getSm():

   965                     sync_manager_control_byte = ExtractHexDecValue(sync_manager.getControlByte())

   966                     sync_manager_direction = sync_manager_control_byte & 0x0c

   967                     if sync_manager_direction:

   968                         sync_managers.append(LOCATION_VAR_OUTPUT)

   969                     else:

   970                         sync_managers.append(LOCATION_VAR_INPUT)

   971                 

   972                 entries = device.GetEntriesList().items()

   973                 entries.sort()

   974                 for (index, subindex), entry in entries:

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

   976                     if var_size is not None:

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

   978                         if var_class is not None:

   979                             if var_class == LOCATION_VAR_INPUT:

   980                                 var_dir = "%I"

   981                             else:

   982                                 var_dir = "%Q"    

   983                         

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

   985                                          "type": var_class,

   986                                          "size": var_size,

   987                                          "IEC_type": entry["Type"],

   988                                          "var_name": "%s_%4.4x_%2.2x" % ("_".join(device_name.split()), index, subindex),

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

   990                                                                                                     (index, subindex)))),

   991                                          "description": "",

   992                                          "children": []})

   993         

   994         return vars

   995     

   996     def CTNTestModified(self):

   997         return self.ChangesToSave or not self.ModelIsSaved()    

   998 

   999     def OnCTNSave(self):

  1000         config_filepath = self.ConfigFileName()

  1001         

  1002         config_text = "<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"no\"?>\n"

  1003         config_extras = {"xmlns:xsi":"http://www.w3.org/2001/XMLSchema-instance",

  1004                   "xsi:noNamespaceSchemaLocation" : "EtherCATInfo.xsd"}

  1005         config_text += self.Config.generateXMLText("EtherCATConfig", 0, config_extras)

  1006 

  1007         config_xmlfile = open(config_filepath,"w")

  1008         config_xmlfile.write(config_text.encode("utf-8"))

  1009         config_xmlfile.close()

  1010         

  1011         process_filepath = self.ProcessVariablesFileName()

  1012         

  1013         process_text = "<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"no\"?>\n"

  1014         process_extras = {"xmlns:xsi":"http://www.w3.org/2001/XMLSchema-instance"}

  1015         process_text += self.ProcessVariables.generateXMLText("ProcessVariables", 0, process_extras)

  1016 

  1017         process_xmlfile = open(process_filepath,"w")

  1018         process_xmlfile.write(process_text.encode("utf-8"))

  1019         process_xmlfile.close()

  1020         

  1021         self.Buffer.CurrentSaved()

  1022         return True

  1023 

  1024     def GetProcessVariableName(self, location, var_type):

  1025         return "__M%s_%s" % (self.GetSizeOfType(var_type), "_".join(map(str, location)))

  1026 

  1027     def _Generate_C(self, buildpath, locations):

  1028         current_location = self.GetCurrentLocation()

  1029         # define a unique name for the generated C file

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

  1031         

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

  1033         

  1034         self.FileGenerator = _EthercatCFileGenerator(self)

  1035         

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

  1037         

  1038         for idx, variable in enumerate(self.ProcessVariables.getvariable()):

  1039             name = None

  1040             var_type = None

  1041             read_from = variable.getReadFrom()

  1042             write_to = variable.getWriteTo()

  1043             if read_from is not None:

  1044                 pos = read_from.getPosition()

  1045                 index = read_from.getIndex()

  1046                 subindex = read_from.getSubIndex()

  1047                 location = current_location + (idx, )

  1048                 var_type = self.GetSlaveVariableDataType(pos, index, subindex)

  1049                 name = self.FileGenerator.DeclareVariable(

  1050                             pos, index, subindex, var_type, "I",

  1051                             self.GetProcessVariableName(location, var_type))

  1052             if write_to is not None:

  1053                 pos = write_to.getPosition()

  1054                 index = write_to.getIndex()

  1055                 subindex = write_to.getSubIndex()

  1056                 if name is None:

  1057                     location = current_location + (idx, )

  1058                     var_type = self.GetSlaveVariableDataType(pos, index, subindex)

  1059                     name = self.GetProcessVariableName(location, var_type)

  1060                 self.FileGenerator.DeclareVariable(

  1061                             pos, index, subindex, var_type, "Q", name, True)

  1062         

  1063         self.FileGenerator.GenerateCFile(Gen_Ethercatfile_path, location_str, self.BaseParams.getIEC_Channel())

  1064         

  1065         LocationCFilesAndCFLAGS.append(

  1066             (current_location, 

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

  1068              True))

  1069         LDFLAGS.append("-lethercat -lrtdm")

  1070         

  1071         return LocationCFilesAndCFLAGS, LDFLAGS, extra_files

  1072 

  1073     ConfNodeMethods = [

  1074         {"bitmap" : "ScanNetwork",

  1075          "name" : _("Scan Network"), 

  1076          "tooltip" : _("Scan Network"),

  1077          "method" : "_ScanNetwork"},

  1078     ]

  1079 

  1080     def CTNGenerate_C(self, buildpath, locations):

  1081         current_location = self.GetCurrentLocation()

  1082         

  1083         slaves = self.GetSlaves()

  1084         for slave_pos in slaves:

  1085             slave = self.GetSlave(slave_pos)

  1086             if slave is not None:

  1087                 self.FileGenerator.DeclareSlave(slave_pos, slave)

  1088         

  1089         for location in locations:

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

  1091             slave_pos = loc[0]

  1092             if slave_pos in slaves and len(loc) == 3 and location["DIR"] != "M":

  1093                 self.FileGenerator.DeclareVariable(

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

  1095         

  1096         return [],"",False

  1097         

  1098 #-------------------------------------------------------------------------------

  1099 #                      Current Buffering Management Functions

  1100 #-------------------------------------------------------------------------------

  1101 

  1102     """

  1103     Return a copy of the config

  1104     """

  1105     def Copy(self, model):

  1106         return cPickle.loads(cPickle.dumps(model))

  1107     

  1108     def CreateBuffer(self, saved):

  1109         self.Buffer = UndoBuffer(cPickle.dumps((self.Config, self.ProcessVariables)), saved)

  1110         

  1111     def BufferModel(self):

  1112         self.Buffer.Buffering(cPickle.dumps((self.Config, self.ProcessVariables)))

  1113     

  1114     def ModelIsSaved(self):

  1115         if self.Buffer is not None:

  1116             return self.Buffer.IsCurrentSaved()

  1117         else:

  1118             return True

  1119 

  1120     def LoadPrevious(self):

  1121         self.Config, self.ProcessVariables = cPickle.loads(self.Buffer.Previous())

  1122     

  1123     def LoadNext(self):

  1124         self.Config, self.ProcessVariables = cPickle.loads(self.Buffer.Next())

  1125     

  1126     def GetBufferState(self):

  1127         first = self.Buffer.IsFirst()

  1128         last = self.Buffer.IsLast()

  1129         return not first, not last

  1130 

  1131 

  1132 SLAVE_PDOS_CONFIGURATION_DECLARATION = """

  1133 /* Slave %(slave)d, "%(device_type)s"

  1134  * Vendor ID:       0x%(vendor).8x

  1135  * Product code:    0x%(product_code).8x

  1136  * Revision number: 0x%(revision_number).8x