mailbox_protocols = ["AoE", "EoE", "CoE", "FoE", "SoE", "VoE"]

def ExtractHexDecValue(value):

"""

convert numerical value in string format into decimal or hex format.

except Exception:

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

def ExtractName(names, default=None):

"""

Extract "name" field from XML entries.

returnVal =result

"""

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

# Common Method For EtherCAT Management

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

[ETHERCAT_VENDOR, ETHERCAT_GROUP, ETHERCAT_DEVICE] = range(3)

def AppendMenu(parent, help, id, kind, text):

if wx.VERSION >= (2, 6, 0):

parent.Append(help=help, id=id, kind=kind, text=text)

else:

parent.Append(helpString=help, id=id, kind=kind, item=text)

def GetVariablesTableColnames(position=False):

_ = lambda x : x

colname = ["#"]

'wo': 'W',

'rw': 'R/W'}

def GetAccessValue(access, pdo_mapping):

value = "SDO: %s" % ACCESS_TYPES.get(access, "")

if pdo_mapping != "":

ETHERCAT_SUBINDEX_MODEL = re.compile("#x([0-9a-fA-F]{0,2})$")

LOCATION_MODEL = re.compile("(?:%[IQM](?:[XBWLD]?([0-9]+(?:\.[0-9]+)*)))$")

class NodeVariablesSizer(wx.FlexGridSizer):

def __init__(self, parent, controler, position_column=False):

event.Skip()

class NodeEditor(ConfTreeNodeEditor):

CONFNODEEDITOR_TABS = [

_("Write to (nodeid, index, subindex)"),

_("Description")]

class ProcessVariablesTable(CustomTable):

def GetValue(self, row, col):

self.ResizeRow(grid, row)

class ProcessVariableDropTarget(wx.TextDropTarget):

def __init__(self, parent):

message.ShowModal()

message.Destroy()

def GetStartupCommandsTableColnames():

_ = lambda x : x

return [_("Position"), _("Index"), _("Subindex"), _("Value"), _("Description")]

class StartupCommandDropTarget(wx.TextDropTarget):

def __init__(self, parent):

message.ShowModal()

message.Destroy()

class StartupCommandsTable(CustomTable):

"""

return row

return None

class MasterNodesVariablesSizer(NodeVariablesSizer):

def __init__(self, parent, controler):

NODE_POSITION_FILTER_FORMAT = _("Node Position: %d")

class MasterEditor(ConfTreeNodeEditor):

CONFNODEEDITOR_TABS = [

# self.FrameLoss2.SetValue(self.MasterState["frameloss2"])

# self.FrameLoss3.SetValue(self.MasterState["frameloss3"])

class LibraryEditorSizer(wx.FlexGridSizer):

def __init__(self, parent, module_library, buttons):

param_infos["description"])

event.Skip()

class DatabaseManagementDialog(wx.Dialog):

def __init__(self, parent, database):

def GetValue(self):

return self.DatabaseSizer.GetSelectedFilePath()

class LibraryEditor(ConfTreeNodeEditor):

CONFNODEEDITOR_TABS = [

from xml.dom import minidom

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

# ----------------------------- For Sync Manager Table -----------------------------------

def GetSyncManagersTableColnames():

"""

_ = lambda x : x

return ["#", _("Name"), _("Start Address"), _("Default Size"), _("Control Byte"), _("Enable")]

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

# Sync Managers Table

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

return row

return self.data[row].get(self.GetColLabelValue(col, False), "")

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

# EtherCAT Management Treebook

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

sel = event.GetSelection()

event.Skip()

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

# For SlaveState Panel

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

except Exception:

pass

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

# For SDO Management Panel

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

sel = self.GetSelection()

event.Skip()

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

# For SDO Grid (fill index, subindex, etc...)

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

}

"""

def ConfigureVariable(entry_infos, str_completion):

entry_infos["data_type"] = DATATYPECONVERSION.get(entry_infos["var_type"], None)

if entry_infos["data_type"] is None:

(" EC_WRITE_%(data_type)s(domain1_pd + slave%(slave)d_%(index).4x_%(subindex).2x, " +

"%(real_var)s);") % entry_infos)

def ExclusionSortFunction(x, y):

if x["matching"] == y["matching"]:

if x["assigned"] and not y["assigned"]:

return cmp(x["count"], y["count"])

return -cmp(x["matching"], y["matching"])

class _EthercatCFileGenerator:

def __init__(self, controler):

# Ethercat CIA402 Node

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

class _EthercatCIA402SlaveCTN(_EthercatSlaveCTN):

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

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

# Etherlab Specific Blocks Library

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

def GetLocalPath(filename):

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

class EtherlabLibrary(POULibrary):

def GetLibraryPath(self):

return GetLocalPath("pous.xml")

EtherCATConfigParser = GenerateParserFromXSD(os.path.join(os.path.dirname(__file__), "EtherCATConfig.xsd"))

def sort_commands(x, y):

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

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

ProcessVariablesParser = GenerateParserFromXSDstring(ProcessVariablesXSD)

class _EthercatCTN:

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

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

def ExtractHexDecValue(value):

try:

return int(value)

except Exception:

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

def GenerateHexDecValue(value, base=10):

if base == 10:

return str(value)

else:

raise ValueError, "Not supported base"

def ExtractName(names, default=None):

if len(names) == 1:

return names[0].getcontent()

EtherCATInfoParser = GenerateParserFromXSD(os.path.join(os.path.dirname(__file__), "EtherCATInfo.xsd"))

EtherCATInfo_XPath = lambda xpath: etree.XPath(xpath)

def HexDecValue(context, *args):

return str(ExtractHexDecValue(args[0][0]))

def EntryName(context, *args):

return ExtractName(args[0],

args[1][0] if len(args) > 1 else None)

("PDO name", str, ""),

("PDO type", str, "")]

class EntryListFactory:

def __init__(self, entries):

return sync_managers

setattr(cls, "GetSyncManagers", GetSyncManagers)

def GroupItemCompare(x, y):

if x["type"] == y["type"]:

if x["type"] == ETHERCAT_GROUP:

return -1

return 1

def SortGroupItems(group):

for item in group["children"]:

if item["type"] == ETHERCAT_GROUP:

SortGroupItems(item)

group["children"].sort(GroupItemCompare)

class ModulesLibrary:

MODULES_EXTRA_PARAMS = [

ModulesDatabase = ModulesLibrary(

os.path.join(USERDATA_DIR, "ethercat_modules"))

class RootClass:

CTNChildrenTypes = [("EthercatNode",_EthercatCTN,"Ethercat Master")]

SDOProc = None

Result = None

def SDOThreadProc(*params):

global Result, SDOProc

if params[0] == "upload":

LogLevelsDict["WARNING"],

"%s : %s" % (command,output))

def EthercatSDOUpload(pos, index, subindex, var_type):

global SDOThread

SDOThread = Thread(target=SDOThreadProc, args=["upload", pos, var_type, index, subindex])

SDOThread.start()

def EthercatSDODownload(pos, index, subindex, var_type, value):

global SDOThread

SDOThread = Thread(target=SDOThreadProc, args=["download", pos, var_type, index, subindex, value])

SDOThread.start()

def GetResult():

global Result

return Result

KMSGPollThread=None

StopKMSGThread=False

def KMSGPollThreadProc():

"""

Logs Kernel messages starting with EtherCAT

msg)

time.sleep(0.5)

def _runtime_etherlab_init():

global KMSGPollThread, StopKMSGThread

StopKMSGThread = False

KMSGPollThread = Thread(target = KMSGPollThreadProc)

KMSGPollThread.start()

def _runtime_etherlab_cleanup():

global KMSGPollThread, StopKMSGThread, SDOProc, SDOThread

try: