return name.getcontent()

return default

# Remote Exec Etherlab Commands

# --------------------- for master ---------------------------

MASTER_STATE = """

returnVal =result

"""

# Common Method For EtherCAT Management

class _CommonSlave:

# ----- Data Structure for ethercat management ----

self.ClearSDODataSet()

# Used Master State

def GetMasterState(self):

"""

Execute "ethercat master" command and parse the execution result

return master_state

# Used Slave State

def RequestSlaveState(self, command):

"""

Set slave state to the specified one using "ethercat states -p %d %s" command.

self.SlaveState = return_val

return return_val

# Used SDO Management

def GetSlaveSDOFromSlave(self):

"""

Get SDO objects information of current slave using "ethercat sdos -p %d" command.

for count in range(6):

self.SaveSDOData.append([])

# Used PDO Monitoring

def RequestPDOInfo(self):

"""

Load slave information from RootClass (XML data) and parse the information (calling SlavePDOData() method).

self.RxPDOInfos = []

self.RxPDOCategorys = []

# Used EEPROM Management

# Base data types in ETG2000; format = {"Name": "BitSize"}

BaseDataTypeDict = {"BOOL": "01",

"SINT": "02",

return eeprom

# Used Register Access

def RegRead(self, offset, length):

"""

Read slave ESC register content using "ethercat reg_read -p %d %s %s" command.

"""

error, return_val = self.Controler.RemoteExec(RESCAN%(self.Controler.GetSlavePos()), return_val = None)

# Common Use Methods

def CheckConnect(self, cyclic_flag):

"""

Check connection status (1) between Beremiz and the master (2) between the master and the slave.

maxx / SCROLLBAR_UNIT, maxy / SCROLLBAR_UNIT, posx, posy)

event.Skip()

# self.MasterState = self.Controler.getMasterState()

# if self.MasterState:

# self.Phase.SetValue(self.MasterState["phase"])

# ------------ for SDO Management --------------------

import string

import wx.grid as gridlib

# ------------ for register management ---------------

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

class SyncManagersTable(CustomTable):

def GetValue(self, row, col):

if row < self.GetNumberRows():

return row

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

# EtherCAT Management Treebook

class EtherCATManagementTreebook(wx.Treebook):

def __init__(self, parent, controler, node_editor):

"""

sel = event.GetSelection()

event.Skip()

# For SlaveState Panel

class SlaveStatePanelClass(wx.Panel):

def __init__(self, parent, controler):

"""

except Exception:

pass

# For SDO Management Panel

class SDOPanelClass(wx.Panel):

def __init__(self, parent, controler):

"""

@return result : output data after check

"""

# string.printable is print this result

allow_range = string.printable

result = check_string

for i in range(0, len(check_string)):

return result

# For SDO Notebook (divide category)

class SDONoteBook(wx.Notebook):

def __init__(self, parent, controler):

"""

sel = self.GetSelection()

event.Skip()

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

class SlaveSDOTable(wx.grid.Grid):

def __init__(self, parent, data):

"""

self.Controler.CommonMethod.CreateErrorDialog('You can input only hex, dec value')

# For PDO Monitoring Panel

# PDO Class UI : Panel -> Choicebook (RxPDO, TxPDO) ->

# Notebook (PDO Index) -> Grid (PDO entry)

class PDOPanelClass(wx.Panel):

def __init__(self, parent, controler):

"""

self.Refresh()

# For PDO Choicebook (divide Tx, Rx PDO)

class PDOChoicebook(wx.Choicebook):

def __init__(self, parent, controler):

"""

event.Skip()

# For PDO Notebook (divide PDO index)

class PDONoteBook(wx.Notebook):

def __init__(self, parent, name, controler):

"""

event.Skip()

# For PDO Grid (fill entry index, subindex etc...)

class PDOEntryTable(wx.grid.Grid):

def __init__(self, parent, info, entry, count):

"""

start_value += 1

# For EEPROM Access Main Panel

# (This class explain EEPROM Access)

class EEPROMAccessPanel(wx.Panel):

def __init__(self, parent, controler):

"""

self.SetSizer(sizer)

# For Smart View Panel

class SlaveSiiSmartView(wx.Panel):

def __init__(self, parent, controler):

"""

''.join(data)

# For Smart View TreeListCtrl

class SmartViewTreeListCtrl(wx.Panel):

def __init__(self, parent, Controler):

"""

self.Tree.Expand(tree)

# For Hex View Panel

# shows EEPROM binary as hex data and characters.

class HexView(wx.Panel):

def __init__(self, parent, controler):

"""

self.SiiGrid.Update()

# For Hex View grid (fill hex data)

class SiiGridTable(wx.grid.Grid):

def __init__(self, parent, controler, row, col):

"""

row = row + 1

# For Register Access Panel

class RegisterAccessPanel(wx.Panel):

def __init__(self, parent, controler):

"""

Get data from the register.

"""

self.Controler.CommonMethod.RegData = ""

for index in range(4):

self.Controler.CommonMethod.RegData = self.Controler.CommonMethod.RegData + " " + self.Controler.CommonMethod.RegRead("0x"+"{:0>4x}".format(index*1024), "0x0400")

self.RegMonitorData)

# For Register Access Notebook (divide index range)

class RegisterNotebook(wx.Notebook):

def __init__(self, parent, controler):

"""

event.Skip()

# For Register Access Notebook Panel

# (Main UI : including main, sub table)

class RegisterNotebookPanel(wx.Panel):

def __init__(self, parent, controler, row, col):

"""

self.SubTable.Update()

# For Register Access Notebook Panel (Main Table)

class RegisterMainTable(wx.grid.Grid):

def __init__(self, parent, row, col, controler):

"""

self.Controler.CommonMethod.CreateErrorDialog('You entered wrong value. You can enter dec or hex value only.')

# For Register Access Notebook Panel (Sub Table)

class RegisterSubTable(wx.grid.Grid):

def __init__(self, parent, row, col):

"""

row = row + 1

# For Master State Panel

class MasterStatePanelClass(wx.Panel):

def __init__(self, parent, controler):

"""

"outputs": []},

]

# Ethercat CIA402 Node

class _EthercatCIA402SlaveCTN(_EthercatSlaveCTN):

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

"push": True},

]

# class code

def __init__(self):

# ----------- call ethercat mng. function --------------

except Exception:

HAS_MCL = False

# Remote Exec Etherlab Commands

SCAN_COMMAND = """

import commands

returnVal = slaves

"""

# Etherlab Specific Blocks Library

def GetLocalPath(filename):

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

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

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

# Ethercat MASTER

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

device, module_extra_params = self.GetModuleInfos(type_infos)

if device is not None:

entries = device.GetEntriesList(limits)

entries_list = entries.items()

entries_list.sort()

entries = []

return [],"",False

# Current Buffering Management Functions

"""

Return a copy of the config

from ConfigEditor import NodeEditor

from CommonEtherCATFunction import _CommonSlave

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

return default

# Ethercat Node

class _EthercatSlaveCTN:

NODE_PROFILE = None

self.CTNParent.SetSlaveType(position, value)

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

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

return value, True

elif path == "SlaveParams.Alias":

self.CTNParent.SetSlaveAlias(position, value)

ScriptDirectory = os.path.split(os.path.realpath(__file__))[0]

# Ethercat ConfNode

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

EtherCATInfo_XPath = lambda xpath: etree.XPath(xpath)

{"name": ExtractName(group.getName(), group_type),

"parent": group.getParentGroup(),

"order": group.getSortOrder(),

"devices": []})

for device in self.devices_xpath(self.modules_infos):

device_group = device.getGroupType()

if not vendor_category["groups"].has_key(device_group):