1230 if var["Location"] != "": |
1230 if var["Location"] != "": |
1231 tempvar.setaddress(var["Location"]) |
1231 tempvar.setaddress(var["Location"]) |
1232 else: |
1232 else: |
1233 tempvar.setaddress(None) |
1233 tempvar.setaddress(None) |
1234 if var['Documentation'] != "": |
1234 if var['Documentation'] != "": |
1235 ft = plcopen.formattedText() |
1235 ft = PLCOpenParser.CreateElement("documentation", "variable") |
1236 ft.setanyText(var['Documentation']) |
1236 ft.setanyText(var['Documentation']) |
1237 tempvar.setdocumentation(ft) |
1237 tempvar.setdocumentation(ft) |
1238 |
1238 |
1239 # Add variable to varList |
1239 # Add variable to varList |
1240 current_varlist.appendvariable(tempvar) |
1240 current_varlist.appendvariable(tempvar) |
1364 vars = [] |
1364 vars = [] |
1365 project = self.GetProject(debug) |
1365 project = self.GetProject(debug) |
1366 if project is not None: |
1366 if project is not None: |
1367 # Found the resource corresponding to name |
1367 # Found the resource corresponding to name |
1368 resource = project.getconfigurationResource(config_name, name) |
1368 resource = project.getconfigurationResource(config_name, name) |
1369 if resource: |
1369 if resource is not None: |
1370 # Extract variables from every varLists |
1370 # Extract variables from every varLists |
1371 for varlist in resource.getglobalVars(): |
1371 for varlist in resource.getglobalVars(): |
1372 for var in varlist.getvariable(): |
1372 for var in varlist.getvariable(): |
1373 tempvar = self.GetVariableDictionary(varlist, var) |
1373 tempvar = self.GetVariableDictionary(varlist, var) |
1374 tempvar["Class"] = "Global" |
1374 tempvar["Class"] = "Global" |
1481 if pou is not None: |
1481 if pou is not None: |
1482 if pou.interface is None: |
1482 if pou.interface is None: |
1483 pou.interface = PLCOpenParser.CreateElement("interface", "pou") |
1483 pou.interface = PLCOpenParser.CreateElement("interface", "pou") |
1484 # If there isn't any return type yet, add it |
1484 # If there isn't any return type yet, add it |
1485 return_type_obj = pou.interface.getreturnType() |
1485 return_type_obj = pou.interface.getreturnType() |
1486 if not return_type_obj: |
1486 if return_type_obj is None: |
1487 return_type_obj = PLCOpenParser.CreateElement("returnType", "interface") |
1487 return_type_obj = PLCOpenParser.CreateElement("returnType", "interface") |
1488 pou.interface.setreturnType(return_type_obj) |
1488 pou.interface.setreturnType(return_type_obj) |
1489 # Change return type |
1489 # Change return type |
1490 if return_type in self.GetBaseTypes(): |
1490 if return_type in self.GetBaseTypes(): |
1491 return_type_obj.setcontent(PLCOpenParser.CreateElement( |
1491 return_type_obj.setcontent(PLCOpenParser.CreateElement( |
1498 return_type.setcontent(derived_type) |
1498 return_type.setcontent(derived_type) |
1499 self.Project.RefreshElementUsingTree() |
1499 self.Project.RefreshElementUsingTree() |
1500 self.Project.RefreshCustomBlockTypes() |
1500 self.Project.RefreshCustomBlockTypes() |
1501 |
1501 |
1502 def UpdateProjectUsedPous(self, old_name, new_name): |
1502 def UpdateProjectUsedPous(self, old_name, new_name): |
1503 if self.Project: |
1503 if self.Project is not None: |
1504 self.Project.updateElementName(old_name, new_name) |
1504 self.Project.updateElementName(old_name, new_name) |
1505 |
1505 |
1506 def UpdateEditedElementUsedVariable(self, tagname, old_name, new_name): |
1506 def UpdateEditedElementUsedVariable(self, tagname, old_name, new_name): |
1507 pou = self.GetEditedElement(tagname) |
1507 pou = self.GetEditedElement(tagname) |
1508 if pou: |
1508 if pou is not None: |
1509 pou.updateElementName(old_name, new_name) |
1509 pou.updateElementName(old_name, new_name) |
1510 |
1510 |
1511 # Return the return type of the pou given by its name |
1511 # Return the return type of the pou given by its name |
1512 def GetPouInterfaceReturnTypeByName(self, name): |
1512 def GetPouInterfaceReturnTypeByName(self, name): |
1513 project = self.GetProject(debug) |
1513 project = self.GetProject(debug) |
1936 else: |
1936 else: |
1937 derived_datatype = PLCOpenParser.CreateElement("derived", "dataType") |
1937 derived_datatype = PLCOpenParser.CreateElement("derived", "dataType") |
1938 derived_datatype.setname(infos["base_type"]) |
1938 derived_datatype.setname(infos["base_type"]) |
1939 datatype.baseType.setcontent(derived_datatype) |
1939 datatype.baseType.setcontent(derived_datatype) |
1940 elif infos["type"] == "Subrange": |
1940 elif infos["type"] == "Subrange": |
1941 datatype.baseType.setcontent(PLCOpenParser.CreateElement( |
1941 subrange = PLCOpenParser.CreateElement( |
1942 "subrangeUnsigned" |
1942 "subrangeUnsigned" |
1943 if infos["base_type"] in GetSubTypes("ANY_UINT") |
1943 if infos["base_type"] in GetSubTypes("ANY_UINT") |
1944 else "subrangeSigned", "dataType")) |
1944 else "subrangeSigned", "dataType") |
|
1945 datatype.baseType.setcontent(subrange) |
1945 subrange.range.setlower(infos["min"]) |
1946 subrange.range.setlower(infos["min"]) |
1946 subrange.range.setupper(infos["max"]) |
1947 subrange.range.setupper(infos["max"]) |
1947 if infos["base_type"] in self.GetBaseTypes(): |
1948 if infos["base_type"] in self.GetBaseTypes(): |
1948 subrange.baseType.setcontent( |
1949 subrange.baseType.setcontent( |
1949 PLCOpenParser.CreateElement(infos["base_type"])) |
1950 PLCOpenParser.CreateElement(infos["base_type"], "dataType")) |
1950 else: |
1951 else: |
1951 derived_datatype = PLCOpenParser.CreateElement("derived", "dataType") |
1952 derived_datatype = PLCOpenParser.CreateElement("derived", "dataType") |
1952 derived_datatype.setname(infos["base_type"]) |
1953 derived_datatype.setname(infos["base_type"]) |
1953 subrange.baseType.setcontent(derived_datatype) |
1954 subrange.baseType.setcontent(derived_datatype) |
1954 elif infos["type"] == "Enumerated": |
1955 elif infos["type"] == "Enumerated": |
1955 enumerated = PLCOpenParser.CreateElement("enum", "dataType") |
1956 enumerated = PLCOpenParser.CreateElement("enum", "dataType") |
|
1957 datatype.baseType.setcontent(enumerated) |
1956 values = PLCOpenParser.CreateElement("values", "enum") |
1958 values = PLCOpenParser.CreateElement("values", "enum") |
1957 enumerated.setvalues(values) |
1959 enumerated.setvalues(values) |
1958 for i, enum_value in enumerate(infos["values"]): |
1960 for i, enum_value in enumerate(infos["values"]): |
1959 value = PLCOpenParser.CreateElement("value", "values") |
1961 value = PLCOpenParser.CreateElement("value", "values") |
1960 value.setname(enum_value) |
1962 value.setname(enum_value) |
1961 if i == 0: |
1963 if i == 0: |
1962 values.setvalue([value]) |
1964 values.setvalue([value]) |
1963 else: |
1965 else: |
1964 values.appendvalue(value) |
1966 values.appendvalue(value) |
1965 datatype.baseType.setcontent(enumerated) |
|
1966 elif infos["type"] == "Array": |
1967 elif infos["type"] == "Array": |
1967 array = PLCOpenParser.CreateElement("array", "dataType") |
1968 array = PLCOpenParser.CreateElement("array", "dataType") |
|
1969 datatype.baseType.setcontent(array) |
1968 for i, dimension in enumerate(infos["dimensions"]): |
1970 for i, dimension in enumerate(infos["dimensions"]): |
1969 dimension_range = PLCOpenParser.CreateElement("dimension", "array") |
1971 dimension_range = PLCOpenParser.CreateElement("dimension", "array") |
1970 dimension_range.setlower(dimension[0]) |
1972 dimension_range.setlower(dimension[0]) |
1971 dimension_range.setupper(dimension[1]) |
1973 dimension_range.setupper(dimension[1]) |
1972 if i == 0: |
1974 if i == 0: |
1980 else infos["base_type"], "dataType")) |
1982 else infos["base_type"], "dataType")) |
1981 else: |
1983 else: |
1982 derived_datatype = PLCOpenParser.CreateElement("derived", "dataType") |
1984 derived_datatype = PLCOpenParser.CreateElement("derived", "dataType") |
1983 derived_datatype.setname(infos["base_type"]) |
1985 derived_datatype.setname(infos["base_type"]) |
1984 array.baseType.setcontent(derived_datatype) |
1986 array.baseType.setcontent(derived_datatype) |
1985 datatype.baseType.setcontent(array) |
|
1986 elif infos["type"] == "Structure": |
1987 elif infos["type"] == "Structure": |
1987 struct = PLCOpenParser.CreateElement("struct", "dataType") |
1988 struct = PLCOpenParser.CreateElement("struct", "dataType") |
|
1989 datatype.baseType.setcontent(struct) |
1988 for i, element_infos in enumerate(infos["elements"]): |
1990 for i, element_infos in enumerate(infos["elements"]): |
1989 element = PLCOpenParser.CreateElement("variable", "struct") |
1991 element = PLCOpenParser.CreateElement("variable", "struct") |
1990 element.setname(element_infos["Name"]) |
1992 element.setname(element_infos["Name"]) |
1991 element_type = PLCOpenParser.CreateElement("type", "variable") |
1993 element_type = PLCOpenParser.CreateElement("type", "variable") |
1992 if isinstance(element_infos["Type"], TupleType): |
1994 if isinstance(element_infos["Type"], TupleType): |
1993 if element_infos["Type"][0] == "array": |
1995 if element_infos["Type"][0] == "array": |
1994 array_type, base_type_name, dimensions = element_infos["Type"] |
1996 array_type, base_type_name, dimensions = element_infos["Type"] |
1995 array = PLCOpenParser.CreateElement("array", "dataType") |
1997 array = PLCOpenParser.CreateElement("array", "dataType") |
|
1998 element_type.setcontent(array) |
1996 for j, dimension in enumerate(dimensions): |
1999 for j, dimension in enumerate(dimensions): |
1997 dimension_range = PLCOpenParser.CreateElement("dimension", "array") |
2000 dimension_range = PLCOpenParser.CreateElement("dimension", "array") |
1998 dimension_range.setlower(dimension[0]) |
2001 dimension_range.setlower(dimension[0]) |
1999 dimension_range.setupper(dimension[1]) |
2002 dimension_range.setupper(dimension[1]) |
2000 if j == 0: |
2003 if j == 0: |
2008 else base_type_name, "dataType")) |
2011 else base_type_name, "dataType")) |
2009 else: |
2012 else: |
2010 derived_datatype = PLCOpenParser.CreateElement("derived", "dataType") |
2013 derived_datatype = PLCOpenParser.CreateElement("derived", "dataType") |
2011 derived_datatype.setname(base_type_name) |
2014 derived_datatype.setname(base_type_name) |
2012 array.baseType.setcontent(derived_datatype) |
2015 array.baseType.setcontent(derived_datatype) |
2013 element_type.setcontent(array) |
|
2014 elif element_infos["Type"] in self.GetBaseTypes(): |
2016 elif element_infos["Type"] in self.GetBaseTypes(): |
2015 element_type.setcontent( |
2017 element_type.setcontent( |
2016 PLCOpenParser.CreateElement( |
2018 PLCOpenParser.CreateElement( |
2017 element_infos["Type"].lower() |
2019 element_infos["Type"].lower() |
2018 if element_infos["Type"] in ["STRING", "WSTRING"] |
2020 if element_infos["Type"] in ["STRING", "WSTRING"] |
2028 element.setinitialValue(value) |
2030 element.setinitialValue(value) |
2029 if i == 0: |
2031 if i == 0: |
2030 struct.setvariable([element]) |
2032 struct.setvariable([element]) |
2031 else: |
2033 else: |
2032 struct.appendvariable(element) |
2034 struct.appendvariable(element) |
2033 datatype.baseType.setcontent(struct) |
|
2034 if infos["initial"] != "": |
2035 if infos["initial"] != "": |
2035 if datatype.initialValue is None: |
2036 if datatype.initialValue is None: |
2036 datatype.initialValue = PLCOpenParser.CreateElement("initialValue", "dataType") |
2037 datatype.initialValue = PLCOpenParser.CreateElement("initialValue", "dataType") |
2037 datatype.initialValue.setvalue(infos["initial"]) |
2038 datatype.initialValue.setvalue(infos["initial"]) |
2038 else: |
2039 else: |
2703 if param == "name": |
2704 if param == "name": |
2704 variable = PLCOpenParser.CreateElement("variable", "contact") |
2705 variable = PLCOpenParser.CreateElement("variable", "contact") |
2705 variable.text = value |
2706 variable.text = value |
2706 contact.setvariable(variable) |
2707 contact.setvariable(variable) |
2707 elif param == "type": |
2708 elif param == "type": |
2708 if value == CONTACT_NORMAL: |
2709 negated, edge = { |
2709 contact.setnegated(False) |
2710 CONTACT_NORMAL: (False, "none"), |
2710 contact.setedge("none") |
2711 CONTACT_REVERSE: (True, "none"), |
2711 elif value == CONTACT_REVERSE: |
2712 CONTACT_RISING: (False, "rising"), |
2712 contact.setnegated(True) |
2713 CONTACT_FALLING: (False, "falling")}[value] |
2713 contact.setedge("none") |
2714 contact.setnegated(negated) |
2714 elif value == CONTACT_RISING: |
2715 contact.setedge(edge) |
2715 contact.setnegated(False) |
|
2716 contact.setedge("rising") |
|
2717 elif value == CONTACT_FALLING: |
|
2718 contact.setnegated(False) |
|
2719 contact.setedge("falling") |
|
2720 elif param == "height": |
2716 elif param == "height": |
2721 contact.setheight(value) |
2717 contact.setheight(value) |
2722 elif param == "width": |
2718 elif param == "width": |
2723 contact.setwidth(value) |
2719 contact.setwidth(value) |
2724 elif param == "x": |
2720 elif param == "x": |
2753 if param == "name": |
2749 if param == "name": |
2754 variable = PLCOpenParser.CreateElement("variable", "coil") |
2750 variable = PLCOpenParser.CreateElement("variable", "coil") |
2755 variable.text = value |
2751 variable.text = value |
2756 coil.setvariable(variable) |
2752 coil.setvariable(variable) |
2757 elif param == "type": |
2753 elif param == "type": |
2758 if value == COIL_NORMAL: |
2754 negated, storage, edge = { |
2759 coil.setnegated(False) |
2755 COIL_NORMAL: (False, "none", "none"), |
2760 coil.setstorage("none") |
2756 COIL_REVERSE: (True, "none", "none"), |
2761 coil.setedge("none") |
2757 COIL_SET: (False, "set", "none"), |
2762 elif value == COIL_REVERSE: |
2758 COIL_RESET: (False, "reset", "none"), |
2763 coil.setnegated(True) |
2759 COIL_RISING: (False, "none", "rising"), |
2764 coil.setstorage("none") |
2760 COIL_FALLING: (False, "none", "falling")}[value] |
2765 coil.setedge("none") |
2761 coil.setnegated(negated) |
2766 elif value == COIL_SET: |
2762 coil.setstorage(storage) |
2767 coil.setnegated(False) |
2763 coil.setedge(edge) |
2768 coil.setstorage("set") |
|
2769 coil.setedge("none") |
|
2770 elif value == COIL_RESET: |
|
2771 coil.setnegated(False) |
|
2772 coil.setstorage("reset") |
|
2773 coil.setedge("none") |
|
2774 elif value == COIL_RISING: |
|
2775 coil.setnegated(False) |
|
2776 coil.setstorage("none") |
|
2777 coil.setedge("rising") |
|
2778 elif value == COIL_FALLING: |
|
2779 coil.setnegated(False) |
|
2780 coil.setstorage("none") |
|
2781 coil.setedge("falling") |
|
2782 elif param == "height": |
2764 elif param == "height": |
2783 coil.setheight(value) |
2765 coil.setheight(value) |
2784 elif param == "width": |
2766 elif param == "width": |
2785 coil.setwidth(value) |
2767 coil.setwidth(value) |
2786 elif param == "x": |
2768 elif param == "x": |
3044 if resource is not None: |
3026 if resource is not None: |
3045 resource.settask([]) |
3027 resource.settask([]) |
3046 resource.setpouInstance([]) |
3028 resource.setpouInstance([]) |
3047 task_list = {} |
3029 task_list = {} |
3048 for task in tasks: |
3030 for task in tasks: |
3049 new_task = plcopen.resource_task() |
3031 new_task = PLCOpenParser.CreateElement("task", "resource") |
|
3032 resource.appendtask(new_task) |
3050 new_task.setname(task["Name"]) |
3033 new_task.setname(task["Name"]) |
3051 if task["Triggering"] == "Interrupt": |
3034 if task["Triggering"] == "Interrupt": |
3052 new_task.setsingle(task["Single"]) |
3035 new_task.setsingle(task["Single"]) |
3053 ## result = duration_model.match(task["Interval"]).groups() |
3036 ## result = duration_model.match(task["Interval"]).groups() |
3054 ## if reduce(lambda x, y: x or y != None, result): |
3037 ## if reduce(lambda x, y: x or y != None, result): |
3064 if task["Triggering"] == "Cyclic": |
3047 if task["Triggering"] == "Cyclic": |
3065 new_task.setinterval(task["Interval"]) |
3048 new_task.setinterval(task["Interval"]) |
3066 new_task.setpriority(int(task["Priority"])) |
3049 new_task.setpriority(int(task["Priority"])) |
3067 if task["Name"] != "": |
3050 if task["Name"] != "": |
3068 task_list[task["Name"]] = new_task |
3051 task_list[task["Name"]] = new_task |
3069 resource.appendtask(new_task) |
|
3070 for instance in instances: |
3052 for instance in instances: |
3071 new_instance = plcopen.pouInstance() |
3053 task = task_list.get(instance["Task"]) |
|
3054 if task is not None: |
|
3055 new_instance = PLCOpenParser.CreateElement("pouInstance", "task") |
|
3056 task.appendpouInstance(new_instance) |
|
3057 else: |
|
3058 new_instance = PLCOpenParser.CreateElement("pouInstance", "resource") |
|
3059 resource.appendpouInstance(new_instance) |
3072 new_instance.setname(instance["Name"]) |
3060 new_instance.setname(instance["Name"]) |
3073 new_instance.settypeName(instance["Type"]) |
3061 new_instance.settypeName(instance["Type"]) |
3074 task_list.get(instance["Task"], resource).appendpouInstance(new_instance) |
|
3075 |
3062 |
3076 def GetEditedResourceInfos(self, tagname, debug = False): |
3063 def GetEditedResourceInfos(self, tagname, debug = False): |
3077 resource = self.GetEditedElement(tagname, debug) |
3064 resource = self.GetEditedElement(tagname, debug) |
3078 if resource is not None: |
3065 if resource is not None: |
3079 tasks = resource.gettask() |
3066 tasks = resource.gettask() |