def Usage(self):

print "Usage:"

print ""

print "Supported options:"

print "-h --help Print this help"

print "-u --updatecheck URL Retrieve update information by checking URL"

print "-e --extend PathToExtension Extend IDE functionality by loading at start additional extensions"

print ""

def SetCmdOptions(self):

self.shortCmdOpts = "hu:e:"

wx.MessageBox(version.GetCommunityHelpMsg(), _(u'Community support'), wx.OK | wx.ICON_INFORMATION)

}

id = wx.NewId()

self.Bind(wx.EVT_MENU, handler, id=id)

parent.Append(help='', id=wx.ID_ABOUT,

kind=wx.ITEM_NORMAL, text=_(u'About'))

self.Bind(wx.EVT_MENU, self.OnAboutMenu, id=wx.ID_ABOUT)

self.ConnectionStatusBar = esb.EnhancedStatusBar(self, style=wx.ST_SIZEGRIP)

self._init_coll_ConnectionStatusBar_Fields(self.ConnectionStatusBar)

self.ProgressStatusBar = wx.Gauge(self.ConnectionStatusBar, -1, range = 100)

self.ProgressStatusBar.Hide()

self.SetStatusBar(self.ConnectionStatusBar)

# commands invoked by build process by default are

# found here.

os.environ["PATH"] = os.getcwd()+';'+os.environ["PATH"]

def __init__(self, parent, projectOpen=None, buildpath=None, ctr=None, debug=True):

# Add beremiz's icon in top left corner of the frame

self.icon = wx.Icon(Bpath("images", "brz.ico"), wx.BITMAP_TYPE_ICO)

self.__init_execute_path()

IDEFrame.__init__(self, parent, debug)

self.Log = LogPseudoFile(self.LogConsole,self.SelectTab)

self.Close()

def OnAboutMenu(self, event):

ShowAboutDialog(self, info)

def OnProjectTreeItemBeginEdit(self, event):

def OnTaskBarChangeInterface(self, evt):

ip_addr = self.pyroserver.ip_addr

ip_addr = '' if ip_addr is None else ip_addr

dlg.SetTests([(re.compile('\d{1,3}(?:\.\d{1,3}){3}$').match, _("IP is not valid!")),

( lambda x :len([x for x in x.split(".") if 0 <= int(x) <= 255]) == 4, _("IP is not valid!"))

])

SECTION_TAG_ELEMENT = "<xsd:element name=\"%s\" type=\"CodeText\"/>"

class CodeFile:

CODEFILE_NAME = "CodeFile"

SECTIONS_NAMES = []

def __init__(self):

sections_str = {"codefile_name": self.CODEFILE_NAME}

if "includes" in self.SECTIONS_NAMES:

sections_str["sections"] = "\n".join(

[SECTION_TAG_ELEMENT % name

for name in self.SECTIONS_NAMES if name != "includes"])

self.CodeFileParser = GenerateParserFromXSDstring(

CODEFILE_XSD % sections_str)

self.CodeFileVariables = etree.XPath("variables/variable")

filepath = self.CodeFileName()

if os.path.isfile(filepath):

xmlfile = open(filepath, 'r')

codefile_xml = xmlfile.read()

xmlfile.close()

codefile_xml = codefile_xml.replace(

'<%s xmlns:xhtml="http://www.w3.org/1999/xhtml">' % self.CODEFILE_NAME)

for cre, repl in [

(re.compile("(?<!<xhtml:p>)(?:<!\[CDATA\[)"), "<xhtml:p><![CDATA["),

(re.compile("(?:]]>)(?!</xhtml:p>)"), "]]></xhtml:p>")]:

codefile_xml = cre.sub(repl, codefile_xml)

try:

self.CodeFile, error = self.CodeFileParser.LoadXMLString(codefile_xml)

if error is not None:

def GenerateNewName(self, format, start_idx):

return self.GetCTRoot().GenerateNewName(

None, None, format, start_idx,

for var in self.CodeFile.variables.getvariable()]))

def SetVariables(self, variables):

variable.setonchange(var["OnChange"])

variable.setopts(var["Options"])

self.CodeFile.variables.appendvariable(variable)

def GetVariables(self):

datas = []

for var in self.CodeFileVariables(self.CodeFile):

"Initial" : var.getinitial(),

"Description" : var.getdesc(),

"OnChange" : var.getonchange(),

section_code = parts.get(section)

if section_code is not None:

getattr(self.CodeFile, section).setanyText(section_code)

def GetTextParts(self):

return dict([(section, getattr(self.CodeFile, section).getanyText())

for section in self.SECTIONS_NAMES])

def CTNTestModified(self):

def OnCTNSave(self, from_project_path=None):

filepath = self.CodeFileName()

xmlfile = open(filepath,"w")

xmlfile.write(etree.tostring(

encoding='utf-8'))

xmlfile.close()

self.MarkCodeFileAsSaved()

return True

variables = self.CodeFileVariables(self.CodeFile)

ret = [(variable.getname(),

variable.gettype(),

for variable in variables]

ret.extend([("On"+variable.getname()+"Change", "python_poll", "")

for variable in variables

def BufferCodeFile(self):

self.CodeFileBuffer.Buffering(self.CodeFileParser.Dumps(self.CodeFile))

def StartBuffering(self):

self.Buffering = True

def EndBuffering(self):

if self.Buffering:

self.CodeFileBuffer.Buffering(self.CodeFileParser.Dumps(self.CodeFile))

self.Buffering = False

def MarkCodeFileAsSaved(self):

self.EndBuffering()

self.CodeFileBuffer.CurrentSaved()

def CodeFileIsSaved(self):

return self.CodeFileBuffer.IsCurrentSaved() and not self.Buffering

def LoadPrevious(self):

self.EndBuffering()

self.CodeFile = self.CodeFileParser.Loads(self.CodeFileBuffer.Previous())

def LoadNext(self):

self.CodeFile = self.CodeFileParser.Loads(self.CodeFileBuffer.Next())

def GetBufferState(self):

first = self.CodeFileBuffer.IsFirst() and not self.Buffering

last = self.CodeFileBuffer.IsLast()

return not first, not last

LibraryControler = None

EditorType = ConfTreeNodeEditor

IconPath = None

def _AddParamsMembers(self):

self.CTNParams = None

if self.XSD:

setattr(self, name, obj)

def __init__(self):

self.BaseParams = _BaseParamsParser.CreateRoot()

self.MandatoryParams = ("BaseParams", self.BaseParams)

self._AddParamsMembers()

self._View = None

# copy ConfNodeMethods so that it can be later customized

self.ConfNodeMethods = [dic.copy() for dic in self.ConfNodeMethods]

def ConfNodeBaseXmlFilePath(self, CTNName=None):

return os.path.join(self.CTNPath(CTNName), "baseconfnode.xml")

def ConfNodeXmlFilePath(self, CTNName=None):

return os.path.join(self.CTNPath(CTNName), "confnode.xml")

project_path = self.CTNParent.CTNPath()

return os.path.join(project_path,

CTNName + NameTypeSeparator + self.CTNType)

def CTNName(self):

return self.BaseParams.getName()

def CTNEnabled(self):

return self.BaseParams.getEnabled()

def CTNFullName(self):

parent = self.CTNParent.CTNFullName()

if parent != "":

return parent + "." + self.CTNName()

return self.BaseParams.getName()

def GetIconName(self):

return None

def CTNTestModified(self):

return self.ChangesToSave

return True

return False

def RemoteExec(self, script, **kwargs):

return self.CTNParent.RemoteExec(script, **kwargs)

def OnCTNSave(self, from_project_path=None):

#Default, do nothing and return success

return True

if self.CTNParams:

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

return params

def SetParamsAttribute(self, path, value):

self.ChangesToSave = True

# Filter IEC_Channel and Name, that have specific behavior

res = self.FindNewName(value)

self.CTNRequestSave()

return res, True

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

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

self.MandatoryParams[1].setElementValue(parts[1], value)

if not os.path.isdir(ctnpath):

# Create it

os.mkdir(ctnpath)

# generate XML for base XML parameters controller of the confnode

if self.MandatoryParams:

BaseXMLFile = open(self.ConfNodeBaseXmlFilePath(),'w')

BaseXMLFile.write(etree.tostring(

encoding='utf-8'))

BaseXMLFile.close()

# generate XML for XML parameters controller of the confnode

if self.CTNParams:

XMLFile = open(self.ConfNodeXmlFilePath(),'w')

XMLFile.write(etree.tostring(

encoding='utf-8'))

XMLFile.close()

# Call the confnode specific OnCTNSave method

result = self.OnCTNSave(from_project_path)

if not result:

return _("Error while saving \"%s\"\n")%self.CTNPath()

# mark confnode as saved

self.ChangesToSave = False

# go through all children and do the same

if result:

return result

return None

def CTNImport(self, src_CTNPath):

shutil.copytree(src_CTNPath, self.CTNPath)

return True

@return: [(instance_name, instance_type),...]

"""

return []

def _GlobalInstances(self):

instances = self.CTNGlobalInstances()

for CTNChild in self.IECSortedChildren():

instances.extend(CTNChild._GlobalInstances())

return instances

def CTNGenerate_C(self, buildpath, locations):

"""

Generate C code

"""

self.GetCTRoot().logger.write_warning(".".join(map(lambda x:str(x), self.GetCurrentLocation())) + " -> Nothing to do\n")

return [],"",False

def _Generate_C(self, buildpath, locations):

# Generate confnodes [(Cfiles, CFLAGS)], LDFLAGS, DoCalls, extra_files

# extra_files = [(fname,fobject), ...]

LDFLAGS=CTNLDFLAGS[:]

else:

LDFLAGS=[]

# recurse through all children, and stack their results

for CTNChild in self.IECSortedChildren():

new_location = CTNChild.GetCurrentLocation()

LocationCFilesAndCFLAGS += _LocationCFilesAndCFLAGS

LDFLAGS += _LDFLAGS

extra_files += _extra_files

return LocationCFilesAndCFLAGS, LDFLAGS, extra_files

def IterChildren(self):

for CTNType, Children in self.Children.items():

for CTNInstance in Children:

yield CTNInstance

def IECSortedChildren(self):

# reorder children by IEC_channels

ordered = [(chld.BaseParams.getIEC_Channel(),chld) for chld in self.IterChildren()]

return zip(*ordered)[1]

else:

return []

def _GetChildBySomething(self, something, toks):

for CTNInstance in self.IterChildren():

# if match component of the name

return self._GetChildBySomething("IEC_Channel", Location)

else:

return self

def GetCurrentLocation(self):

"""

@return: Tupple containing confnode IEC location of current confnode : %I0.0.4.5 => (0,0,4,5)

This function is meant to be overridden by confnodes.

It should returns an list of dictionaries

- IEC_type is an IEC type like BOOL/BYTE/SINT/...

- location is a string of this variable's location, like "%IX0.0.0"

'''

while res in AllNames:

res = "%s_%d"%(BaseDesiredName, suffix)

suffix += 1

# Get old path

oldname = self.CTNPath()

# Check previous confnode existance

#if CurrentChannel == DesiredChannel: return CurrentChannel

# Build a list of used Channels out of parent's Children

AllChannels = self.GetAllChannels()

# Now, try to guess the nearest available channel

res = DesiredChannel

while res in AllChannels: # While channel not free

if self.EditorType is not None:

app_frame = self.GetCTRoot().AppFrame

if self._View is None and not onlyopened:

self._View = self.EditorType(app_frame.TabsOpened, self, app_frame)

if self._View is not None:

if name is None:

name = self.CTNFullName()

app_frame.EditProjectElement(self._View, name)

return self._View

return None

CTNClass, CTNHelp = CTNChildrenTypes[CTNType]

except KeyError:

raise Exception, _("Cannot create child {a1} of type {a2} ").format(a1 = CTNName, a2 = CTNType)

# if CTNClass is a class factory, call it. (prevent unneeded imports)

if type(CTNClass) == types.FunctionType:

CTNClass = CTNClass()

# Eventualy Initialize child instance list for this class of confnode

ChildrenWithSameClass = self.Children.setdefault(CTNType, list())

# Check count

if getattr(CTNClass, "CTNMaxCount", None) and len(ChildrenWithSameClass) >= CTNClass.CTNMaxCount:

msg = _("Max count ({a1}) reached for this confnode of type {a2} ").format(a1 = CTNClass.CTNMaxCount, a2 = CTNType)

raise Exception, msg

# create the final class, derived of provided confnode and template

class FinalCTNClass(CTNClass, ConfigTreeNode):

"""

ConfNode class is derivated into FinalCTNClass before being instanciated

before CTNClass.__init__, and to do the file related stuff.

"""

def __init__(_self):

raise Exception, msg

# Now, self.CTNPath() should be OK

# Check that IEC_Channel is not already in use.

_self.FindNewIEC_Channel(_self.BaseParams.getIEC_Channel())

# Call the confnode real __init__

_self.CTNRequestSave()

#just created, must be saved

_self.ChangesToSave = True

def _getBuildPath(_self):

return self._getBuildPath()

# Create the object out of the resulting class

newConfNodeOpj = FinalCTNClass()

# Store it in CTNgedChils

ChildrenWithSameClass.append(newConfNodeOpj)

return newConfNodeOpj

def ClearChildren(self):

for child in self.IterChildren():

child.ClearChildren()

self.Children = {}

def LoadXMLParams(self, CTNName = None):

methode_name = os.path.join(self.CTNPath(CTNName), "methods.py")

if os.path.isfile(methode_name):

execfile(methode_name)

ConfNodeName = CTNName if CTNName is not None else self.CTNName()

# Get the base xml tree

if self.MandatoryParams:

try:

msg = _("Couldn't load confnode base parameters {a1} :\n {a2}").format(a1 = ConfNodeName, a2 = unicode(exc))

self.GetCTRoot().logger.write_error(msg)

self.GetCTRoot().logger.write_error(traceback.format_exc())

# Get the xml tree

if self.CTNParams:

try:

msg = _("Couldn't load confnode parameters {a1} :\n {a2}").format(a1 = ConfNodeName, a2 = unicode(exc))

self.GetCTRoot().logger.write_error(msg)

self.GetCTRoot().logger.write_error(traceback.format_exc())

def LoadChildren(self):

# Iterate over all CTNName@CTNType in confnode directory, and try to open them

for CTNDir in os.listdir(self.CTNPath()):

msg = _("Could not add child \"{a1}\", type {a2} :\n{a3}\n").format(a1 = pname, a2 = ptype, a3 = unicode(exc))

self.GetCTRoot().logger.write_error(msg)

self.GetCTRoot().logger.write_error(traceback.format_exc())

def _init_icon(self, parent):

if self.icon:

elif parent and parent.icon:

def _init_ctrls(self, prnt):

wx.Frame.__init__(self, id=ID_PLCOPENEDITOR, name='IDEFrame',

parent=prnt, pos=wx.DefaultPosition, size=wx.Size(1000, 600),

self.RefreshPageTitles()

elif item_infos["type"] == ITEM_TRANSITION:

pou_item = self.ProjectTree.GetItemParent(event.GetItem())

if new_name.upper() in [name.upper() for name in self.Controler.GetProjectPouNames()]:

message = _("A POU named \"%s\" already exists!")%new_name

elif new_name.upper() in [name.upper() for name in self.Controler.GetProjectPouVariableNames(pou_name) if name != old_name]:

self.Viewer.DoDrawing(dc, True)

return True

class NativeLibrary(POULibrary):

def GetLibraryPath(self):

connections = content["value"].getconnections()

if not connections:

raise PLCGenException, _("SFC transition in POU \"%s\" must be connected.") % self.Name

connected = self.GetLinkedConnector(link, body)

if connected is not None and not self.ConnectionTypes.has_key(connected):

for related in self.ExtractRelatedConnections(connected):

generator = ProgramGenerator(controler, project, errors, warnings)

generator.GenerateProgram()

return generator.GetGeneratedProgram()

# kind=wx.ITEM_NORMAL, text=u'PLCOpen\tF2')

#AppendMenu(parent, help='', id=wx.ID_HELP_CONTEXT,

# kind=wx.ITEM_NORMAL, text=u'IEC 61131-3\tF3')

handler=lambda event: {

wx.MessageBox(version.GetCommunityHelpMsg(), _(u'Community support'), wx.OK | wx.ICON_INFORMATION)

}

id = wx.NewId()

self.Bind(wx.EVT_MENU, handler, id=id)

AppendMenu(parent, help='', id=wx.ID_ABOUT,

kind=wx.ITEM_NORMAL, text=_(u'About'))

self.Bind(wx.EVT_MENU, self.OnPLCOpenEditorMenu, id=wx.ID_HELP)

frame.Show()

app.MainLoop()

def GetSTCode(self):

if not self.program:

self.program = self.LibraryControler.GenerateProgram()[0]+"\n"

def GetName(self):

return self.LibName

def GetCTR(self):

return self.CTR()

def GetTypes(self):

return {"name" : self.GetName(), "types": self.LibraryControler.Project}

for p in paths:

if test(p):

path = p

return path

def findCmd(self):

cmd="iec2c"+(".exe" if wx.Platform == '__WXMSW__' else "")

paths=[

cmd=os.path.join(path, cmd)

return cmd

def findLibPath(self):

paths=[

os.path.join(base_folder, "matiec", "lib"),

]

path = self.findObject(paths, lambda p:os.path.isfile(os.path.join(p, "ieclib.txt")))

return path

def findLibCPath(self):

path=None

paths=[

def ShowError(self, logger, from_location, to_location):

chunk_infos = self.GetChunkInfos(from_location, to_location)

for infos, (start_row, start_col) in chunk_infos:

col = 1 if (start_row != from_location[0]) else (from_location[1] - start_col)

start = (row, col)

col = 1 if (start_row != to_location[0]) else (to_location[1] - start_col)

end = (row, col)

if self.AppFrame is not None:

self.AppFrame.ShowError(infos, start, end)

except:

text = '(* No IEC code have been generated at that time ! *)'

self._IECCodeView.SetText(text = text)

self._IECCodeView.SetIcon(GetBitmap("ST"))

setattr(self._IECCodeView, "_OnClose", self.OnCloseEditor)

self.ShowMethod("_showIECcode", os.path.isfile(self._getIECcodepath()))

if self.AppFrame is not None and not self.UpdateMethodsFromPLCStatus():

self.AppFrame.RefreshStatusToolBar()

def UpdateButtons(self):

wx.CallAfter(self._UpdateButtons)

def UpdatePLCLog(self, log_count):

if log_count:

if self.AppFrame is not None:

"Disconnected": _("Disconnected")

}

return msgs.get(status, status)

def ShowPLCProgress(self, status = "", progress = 0):

self.AppFrame.ProgressStatusBar.Show()

self.AppFrame.ConnectionStatusBar.SetStatusText(self.GetTextStatus(status), 1)

self.previous_plcstate = ""

self.AppFrame.ProgressStatusBar.Hide()

self.UpdateMethodsFromPLCStatus()

def PullPLCStatusProc(self, event):

self.UpdateMethodsFromPLCStatus()

self.AppFrame.LogViewer.ResetLogCounters();

else:

self.logger.write_error(_("Transfer failed\n"))

else:

self.logger.write_error(_("No PLC to transfer (did build succeed ?)\n"))

class CppEditor(CodeEditor):

"static_cast", "struct", "switch", "template", "this", "throw", "true", "try",

"void", "volatile", "wchar_t", "while"]

COMMENT_HEADER = "/"

def SetCodeLexer(self):

self.SetLexer(stc.STC_LEX_CPP)

self.StyleSetSpec(stc.STC_C_COMMENT, 'fore:#408060,size:%(size)d' % faces)

self.StyleSetSpec(stc.STC_C_COMMENTLINE, 'fore:#408060,size:%(size)d' % faces)

self.StyleSetSpec(stc.STC_C_COMMENTDOC, 'fore:#408060,size:%(size)d' % faces)

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

class CFileEditor(CodeFileEditor):

CONFNODEEDITOR_TABS = [

(_("C code"), "_create_CodePanel")]

CODE_EDITOR = CppEditor

from networkeditortemplate import NetworkEditorTemplate

from editors.ConfTreeNodeEditor import ConfTreeNodeEditor

] = [wx.NewId() for _init_ctrls in range(1)]

] = [wx.NewId() for _init_coll_ConfNodeMenu_Items in range(3)]

[ID_NETWORKEDITORMASTERMENUNODEINFOS, ID_NETWORKEDITORMASTERMENUDS301PROFILE,

ID_NETWORKEDITORMASTERMENUDS302PROFILE, ID_NETWORKEDITORMASTERMENUDSOTHERPROFILE,

] = [wx.NewId() for _init_coll_MasterMenu_Items in range(5)]

[ID_NETWORKEDITORADDMENUSDOSERVER, ID_NETWORKEDITORADDMENUSDOCLIENT,

] = [wx.NewId() for _init_coll_AddMenu_Items in range(6)]

class NetworkEditor(ConfTreeNodeEditor, NetworkEditorTemplate):

ID = ID_NETWORKEDITOR

CONFNODEEDITOR_TABS = [

(_("CANOpen network"), "_create_NetworkEditor")]

def _create_NetworkEditor(self, prnt):

size=wx.Size(0, 0), style=wx.TAB_TRAVERSAL)

NetworkEditorTemplate._init_ctrls(self, self.NetworkEditor)

main_sizer = wx.FlexGridSizer(cols=1, hgap=0, rows=1, vgap=0)

main_sizer.AddGrowableCol(0)

main_sizer.AddGrowableRow(0)

main_sizer.AddWindow(self.NetworkNodes, 0, border=5, flag=wx.GROW|wx.ALL)

self.NetworkEditor.SetSizer(main_sizer)

return self.NetworkEditor

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

ConfTreeNodeEditor.__init__(self, parent, controler, window)

NetworkEditorTemplate.__init__(self, controler, window, False)

self.RefreshNetworkNodes()

self.RefreshBufferState()

def __del__(self):

self.Controler.OnCloseEditor(self)

def GetConfNodeMenuItems(self):

add_menu = [(wx.ITEM_NORMAL, (_('SDO Server'), ID_NETWORKEDITORADDMENUSDOSERVER, '', self.OnAddSDOServerMenu)),

(wx.ITEM_NORMAL, (_('SDO Client'), ID_NETWORKEDITORADDMENUSDOCLIENT, '', self.OnAddSDOClientMenu)),

(wx.ITEM_NORMAL, (_('PDO Receive'), ID_NETWORKEDITORADDMENUPDORECEIVE, '', self.OnAddPDOReceiveMenu)),

(wx.ITEM_NORMAL, (_('Map Variable'), ID_NETWORKEDITORADDMENUMAPVARIABLE, '', self.OnAddMapVariableMenu)),

(wx.ITEM_NORMAL, (_('User Type'), ID_NETWORKEDITORADDMENUUSERTYPE, '', self.OnAddUserTypeMenu))]

profile = self.Manager.GetCurrentProfileName()

if profile not in ("None", "DS-301"):

other_profile_text = _("%s Profile") % profile

add_menu.append((wx.ITEM_NORMAL, (text, wx.NewId(), '', self.GetProfileCallBack(text))))

else:

other_profile_text = _('Other Profile')

master_menu = [(wx.ITEM_NORMAL, (_('DS-301 Profile'), ID_NETWORKEDITORMASTERMENUDS301PROFILE, '', self.OnCommunicationMenu)),

(wx.ITEM_NORMAL, (_('DS-302 Profile'), ID_NETWORKEDITORMASTERMENUDS302PROFILE, '', self.OnOtherCommunicationMenu)),

(wx.ITEM_NORMAL, (other_profile_text, ID_NETWORKEDITORMASTERMENUDSOTHERPROFILE, '', self.OnEditProfileMenu)),

(wx.ITEM_SEPARATOR, None),

(add_menu, (_('Add'), ID_NETWORKEDITORMASTERMENUADD))]

return [(wx.ITEM_NORMAL, (_('Add slave'), ID_NETWORKEDITORCONFNODEMENUADDSLAVE, '', self.OnAddSlaveMenu)),

(wx.ITEM_NORMAL, (_('Remove slave'), ID_NETWORKEDITORCONFNODEMENUREMOVESLAVE, '', self.OnRemoveSlaveMenu)),

(wx.ITEM_SEPARATOR, None),

(master_menu, (_('Master'), ID_NETWORKEDITORCONFNODEMENUMASTER))]

def RefreshMainMenu(self):

pass

def RefreshConfNodeMenu(self, confnode_menu):

confnode_menu.Enable(ID_NETWORKEDITORCONFNODEMENUMASTER, self.NetworkNodes.GetSelection() == 0)

def RefreshView(self):

ConfTreeNodeEditor.RefreshView(self)

self.RefreshCurrentIndexList()

def RefreshBufferState(self):

NetworkEditorTemplate.RefreshBufferState(self)

self.ParentWindow.RefreshTitle()

self.ParentWindow.RefreshFileMenu()

self.ParentWindow.RefreshEditMenu()

self.ParentWindow.RefreshPageTitles()

def OnNodeSelectedChanged(self, event):

NetworkEditorTemplate.OnNodeSelectedChanged(self, event)

wx.CallAfter(self.ParentWindow.RefreshEditMenu)

[ID_SLAVEEDITORCONFNODEMENUNODEINFOS, ID_SLAVEEDITORCONFNODEMENUDS301PROFILE,

ID_SLAVEEDITORCONFNODEMENUDS302PROFILE, ID_SLAVEEDITORCONFNODEMENUDSOTHERPROFILE,

] = [wx.NewId() for _init_coll_ConfNodeMenu_Items in range(5)]

[ID_SLAVEEDITORADDMENUSDOSERVER, ID_SLAVEEDITORADDMENUSDOCLIENT,

] = [wx.NewId() for _init_coll_AddMenu_Items in range(6)]

class SlaveEditor(ConfTreeNodeEditor, NodeEditorTemplate):

CONFNODEEDITOR_TABS = [

(_("CANOpen slave"), "_create_SlaveNodeEditor")]

def _create_SlaveNodeEditor(self, prnt):

self.SlaveNodeEditor = EditingPanel(prnt, self, self.Controler, self.Editable)

return self.SlaveNodeEditor

def __init__(self, parent, controler, window, editable=True):

self.Editable = editable

ConfTreeNodeEditor.__init__(self, parent, controler, window)

NodeEditorTemplate.__init__(self, controler, window, False)

def __del__(self):

self.Controler.OnCloseEditor(self)

def GetConfNodeMenuItems(self):

if self.Editable:

add_menu = [(wx.ITEM_NORMAL, (_('SDO Server'), ID_SLAVEEDITORADDMENUSDOSERVER, '', self.OnAddSDOServerMenu)),

(wx.ITEM_NORMAL, (_('PDO Receive'), ID_SLAVEEDITORADDMENUPDORECEIVE, '', self.OnAddPDOReceiveMenu)),

(wx.ITEM_NORMAL, (_('Map Variable'), ID_SLAVEEDITORADDMENUMAPVARIABLE, '', self.OnAddMapVariableMenu)),

(wx.ITEM_NORMAL, (_('User Type'), ID_SLAVEEDITORADDMENUUSERTYPE, '', self.OnAddUserTypeMenu))]

profile = self.Controler.GetCurrentProfileName()

if profile not in ("None", "DS-301"):

other_profile_text = _("%s Profile") % profile

add_menu.append((wx.ITEM_NORMAL, (text, wx.NewId(), '', self.GetProfileCallBack(text))))

else:

other_profile_text = _('Other Profile')

return [(wx.ITEM_NORMAL, (_('DS-301 Profile'), ID_SLAVEEDITORCONFNODEMENUDS301PROFILE, '', self.OnCommunicationMenu)),

(wx.ITEM_NORMAL, (_('DS-302 Profile'), ID_SLAVEEDITORCONFNODEMENUDS302PROFILE, '', self.OnOtherCommunicationMenu)),

(wx.ITEM_NORMAL, (other_profile_text, ID_SLAVEEDITORCONFNODEMENUDSOTHERPROFILE, '', self.OnEditProfileMenu)),

(wx.ITEM_SEPARATOR, None),

(add_menu, (_('Add'), ID_SLAVEEDITORCONFNODEMENUADD))]

return []

def RefreshConfNodeMenu(self, confnode_menu):

if self.Editable:

confnode_menu.Enable(ID_SLAVEEDITORCONFNODEMENUDSOTHERPROFILE, False)

def RefreshCurrentIndexList(self):

self.RefreshView()

def RefreshBufferState(self):

self.ParentWindow.RefreshTitle()

self.ParentWindow.RefreshFileMenu()

class MasterViewer(SlaveEditor):

SHOW_BASE_PARAMS = False

SHOW_PARAMS = False

def __init__(self, parent, controler, window, tagname):

SlaveEditor.__init__(self, parent, controler, window, False)

self.TagName = tagname

def GetTagName(self):

return self.TagName

def GetCurrentNodeId(self):

return None

def GetInstancePath(self):

return self.Controler.CTNFullName() + ".generated_master"

def GetTitle(self):

return self.GetInstancePath()

def IsViewing(self, tagname):

return self.GetInstancePath() == tagname

def RefreshView(self):

self.SlaveNodeEditor.RefreshIndexList()

"size": size,

"IEC_type": IECTypeConversion.get(typeinfos["name"]),

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

(index, subindex)))),

"description": "",

"children": []})

</xsd:element>

</xsd:schema>

"""

EditorType = SlaveEditor

IconPath = os.path.join(CanFestivalPath, "objdictgen", "networkedit.png")

self.CreateNewNode(name, # Name - will be changed at build time

id, # NodeID - will be changed at build time

"slave", # Type

profile, # profile

filepath, # prfile filepath

NMT, # NMT

self.CreateNewNode("SlaveNode", # Name - will be changed at build time

0x00, # NodeID - will be changed at build time

"slave", # Type

"None", # profile

"", # prfile filepath

"heartbeat", # NMT

if self._View is not None:

self._View.SetBusId(self.GetCurrentLocation())

return self._View

def _ExportSlave(self):

_("EDS files (*.eds)|*.eds|All files|*.*"),

wx.SAVE|wx.OVERWRITE_PROMPT)

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

result = eds_utils.GenerateEDSFile(dialog.GetPath(), self.GetCurrentNodeCopy())

if result:

self.GetCTRoot().logger.write_error(_("Error: Export slave failed\n"))

ConfNodeMethods = [

{"bitmap" : "ExportSlave",

"tooltip" : _("Export CanOpen slave to EDS file"),

"method" : "_ExportSlave"},

]

def CTNTestModified(self):

return self.ChangesToSave or self.OneFileHasChanged()

def OnCTNSave(self, from_project_path=None):

return self.SaveCurrentInFile(self.GetSlaveODPath())

def SetParamsAttribute(self, path, value):

result = ConfigTreeNode.SetParamsAttribute(self, path, value)

# Filter IEC_Channel and Name, that have specific behavior

if path == "BaseParams.IEC_Channel" and self._View is not None:

self._View.SetBusId(self.GetCurrentLocation())

return result

def GetVariableLocationTree(self):

current_location = self.GetCurrentLocation()

self.BaseParams.getName())

def CTNGenerate_C(self, buildpath, locations):

"""

Generate C code

def LoadPrevious(self):

self.LoadCurrentPrevious()

def LoadNext(self):

self.LoadCurrentNext()

def GetBufferState(self):

return self.GetCurrentBufferState()

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

class MiniNodeManager(NodeManager):

def __init__(self, parent, filepath, fullname):

NodeManager.__init__(self)

self.OpenFileInCurrent(filepath)

self.Parent = parent

self.Fullname = fullname

def GetIconName(self):

return None

def OnCloseEditor(self, view):

self.Parent.OnCloseEditor(view)

def CTNFullName(self):

return self.Fullname

def CTNTestModified(self):

return False

def GetBufferState(self):

return self.GetCurrentBufferState()

ConfNodeMethods = []

class _NodeManager(NodeManager):

def __init__(self, parent, *args, **kwargs):

NodeManager.__init__(self, *args, **kwargs)

self.Parent = parent

def __del__(self):

self.Parent = None

def GetCurrentNodeName(self):

return self.Parent.CTNName()

def GetCurrentNodeID(self):

return self.Parent.CanFestivalNode.getNodeId()

class _NodeListCTN(NodeList):

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

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

</xsd:complexType>

</xsd:element>

</xsd:schema>

EditorType = NetworkEditor

IconPath = os.path.join(CanFestivalPath, "objdictgen", "networkedit.png")

def __init__(self):

manager = _NodeManager(self)

NodeList.__init__(self, manager)

self.LoadProject(self.CTNPath())

self.SetNetworkName(self.BaseParams.getName())

def GetCanDevice(self):

return self.CanFestivalNode.getCAN_Device()

def SetParamsAttribute(self, path, value):

if path == "CanFestivalNode.NodeId":

nodeid = self.CanFestivalNode.getNodeId()

value += dir

if value < 0:

value = nodeid

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

refresh_network = False

# Filter IEC_Channel and Name, that have specific behavior

if path == "BaseParams.IEC_Channel" and self._View is not None:

self._View.SetBusId(self.GetCurrentLocation())

refresh_network = True

elif path == "CanFestivalNode.NodeId":

refresh_network = True

if refresh_network and self._View is not None:

wx.CallAfter(self._View.RefreshBufferState)

return value, refresh

def GetVariableLocationTree(self):

current_location = self.GetCurrentLocation()

nodeindexes = self.SlaveNodes.keys()

"location": self.GetFullIEC_Channel(),

"children": [GetSlaveLocationTree(self.Manager.GetCurrentNodeCopy(),

current_location,

self.SlaveNodes[nodeid]["Name"])

for nodeid in nodeindexes]

}

_GeneratedMasterView = None

def _ShowGeneratedMaster(self):

self._OpenView("Generated master")

def _OpenView(self, name=None, onlyopened=False):

if name == "Generated master":

app_frame = self.GetCTRoot().AppFrame

if not os.path.exists(buildpath):

self.GetCTRoot().logger.write_error(_("Error: No PLC built\n"))

return

masterpath = os.path.join(buildpath, "MasterGenerated.od")

if not os.path.exists(masterpath):

self.GetCTRoot().logger.write_error(_("Error: No Master generated\n"))

return

manager = MiniNodeManager(self, masterpath, self.CTNFullName())

self._GeneratedMasterView = MasterViewer(app_frame.TabsOpened, manager, app_frame, name)

if self._GeneratedMasterView is not None:

app_frame.EditProjectElement(self._GeneratedMasterView, self._GeneratedMasterView.GetInstancePath())

return self._GeneratedMasterView

else:

ConfigTreeNode._OpenView(self, name, onlyopened)

if self._View is not None:

self._View.SetBusId(self.GetCurrentLocation())

return self._View

ConfNodeMethods = [

{"bitmap" : "ShowMaster",

"tooltip" : _("Show Master generated by config_utils"),

"method" : "_ShowGeneratedMaster"}

]

def OnCloseEditor(self, view):

ConfigTreeNode.OnCloseEditor(self, view)

if self._GeneratedMasterView == view:

self._GeneratedMasterView = None

def OnCTNClose(self):

ConfigTreeNode.OnCTNClose(self)

self._CloseView(self._GeneratedMasterView)

def CTNTestModified(self):

return self.ChangesToSave or self.HasChanged()

def OnCTNSave(self, from_project_path=None):

self.SetRoot(self.CTNPath())

if from_project_path is not None:

self.GetEDSFolder())

return self.SaveProject() is None

res = gen_cfile.GenerateFile(Gen_OD_path, master, pointers)

if res :

raise Exception, res

file = open(os.path.join(buildpath, "MasterGenerated.od"), "w")

dump(master, file)

file.close()

return [(Gen_OD_path,local_canfestival_config.getCFLAGS(CanFestivalPath))],"",False

def LoadPrevious(self):

self.Manager.LoadCurrentPrevious()

def LoadNext(self):

self.Manager.LoadCurrentNext()

def GetBufferState(self):

return self.Manager.GetCurrentBufferState()

class RootClass:

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

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

</xsd:element>

</xsd:schema>

"""

CTNChildrenTypes = [("CanOpenNode",_NodeListCTN, "CanOpen Master"),

("CanOpenSlave",_SlaveCTN, "CanOpen Slave")]

def GetParamsAttributes(self, path = None):

if child["name"] == "CAN_Driver":

child["type"] = local_canfestival_config.DLL_LIST

return infos

def GetCanDriver(self):

res = self.CanFestivalInstance.getCAN_Driver()

if not res :

return ""

return res

def CTNGenerate_C(self, buildpath, locations):

can_driver = self.GetCanDriver()

if can_driver is not None:

else:

can_driver_name = ""

format_dict = {"locstr" : "_".join(map(str,self.GetCurrentLocation())),

"candriver" : can_driver_name,

"nodes_includes" : "",

for child in self.IECSortedChildren():

childlocstr = "_".join(map(str,child.GetCurrentLocation()))

nodename = "OD_%s" % childlocstr

# Try to get Slave Node

child_data = getattr(child, "CanFestivalSlaveNode", None)

if child_data is None:

format_dict["nodes_init"] += 'NODE_SLAVE_INIT(%s, %s)\n '%(

nodename,

child_data.getNodeId())

# Include generated OD headers

format_dict["nodes_includes"] += '#include "%s.h"\n'%(nodename)

# Declare CAN channels according user filled config

format_dict["nodes_open"] += 'NODE_OPEN(%s)\n '%(nodename)

format_dict["nodes_close"] += 'NODE_CLOSE(%s)\n '%(nodename)

format_dict["nodes_stop"] += 'NODE_STOP(%s)\n '%(nodename)

filename = paths.AbsNeighbourFile(__file__,"cf_runtime.c")

cf_main = open(filename).read() % format_dict

cf_main_path = os.path.join(buildpath, "CF_%(locstr)s.c"%format_dict)

f.close()

res = [(cf_main_path, local_canfestival_config.getCFLAGS(CanFestivalPath))],local_canfestival_config.getLDFLAGS(CanFestivalPath), True

if can_driver is not None:

can_driver_path = os.path.join(CanFestivalPath,"drivers",can_driver,can_driver_name)

if os.path.exists(can_driver_path):

res += ((can_driver_name, file(can_driver_path,"rb")),)

return res

"LREAL":0x11,"STRING":0x09,"BYTE":0x05,"WORD":0x06,"DWORD":0x07,

"LWORD":0x1B,"WSTRING":0x0B}

RPDO = 1

TPDO = 2

@param size: number of bytes generated

@return: a string containing the value converted

"""

data = ("%" + str(size * 2) + "." + str(size * 2) + "X") % value

list_car = [data[i:i+2] for i in xrange(0, len(data), 2)]

list_car.reverse()

def GetNodePDOIndexes(node, type, parameters = False):

"""

Find the PDO indexes of a node

@param type: type of PDO searched (RPDO or TPDO or both)

@param parameters: indicate which indexes are expected (PDO paramaters : True or PDO mappings : False)

@return: a list of indexes found

"""

indexes = []

if type & RPDO:

indexes.extend([idx for idx in node.GetIndexes() if 0x1400 <= idx <= 0x15FF])

def SearchNodePDOMapping(loc_infos, node):

"""

Find the PDO indexes of a node

@param type: type of PDO searched (RPDO or TPDO or both)

@param parameters: indicate which indexes are expected (PDO paramaters : True or PDO mappings : False)

@return: a list of indexes found

"""

model = (loc_infos["index"] << 16) + (loc_infos["subindex"] << 8)

for PDOidx in GetNodePDOIndexes(node, loc_infos["pdotype"]):

values = node.GetEntry(PDOidx)

if values != None:

@param cobid: PDO generated COB ID

@param transmittype : PDO transmit type

@param pdomapping: list of PDO mappings

"""

dcfdata=[]

# Create entry for RPDO or TPDO parameters and Disable PDO

# ---- INDEX ----- --- SUBINDEX ---- ----- SIZE ------ ------ DATA ------

self.TrashVariables = {}

# Dictionary of pointed variables

self.PointedVariables = {}

self.NodeList = nodelist

self.Manager = self.NodeList.Manager

self.MasterNode = self.Manager.GetCurrentNodeCopy()

def GetPointedVariables(self):

return self.PointedVariables

def RemoveUsedNodeCobId(self, node):

"""

Remove all PDO COB ID used by the given node from the list of available COB ID

@param node: node

@return: a tuple of number of RPDO and TPDO for the node

"""

# Get list of all node TPDO and RPDO indexes

nodeRpdoIndexes = GetNodePDOIndexes(node, RPDO, True)

nodeTpdoIndexes = GetNodePDOIndexes(node, TPDO, True)

# Mark all the COB ID of the node already mapped PDO as not available

for PdoIdx in nodeRpdoIndexes + nodeTpdoIndexes:

pdo_cobid = node.GetEntry(PdoIdx, 0x01)

# Remove COB ID from the list of available COB ID

if pdo_cobid in self.ListCobIDAvailable:

self.ListCobIDAvailable.remove(pdo_cobid)

return len(nodeRpdoIndexes), len(nodeTpdoIndexes)

def PrepareMasterNode(self):

"""

Add mandatory entries for DCF generation into MasterNode.

"""

# Adding DCF entry into Master node

if not self.MasterNode.IsEntry(0x1F22):

self.MasterNode.AddEntry(0x1F22, 1, "")

self.Manager.AddSubentriesToCurrent(0x1F22, 127, self.MasterNode)

# Adding trash mappable variables for unused mapped datas

idxTrashVariables = 0x2000 + self.MasterNode.GetNodeID()

# Add an entry for storing unexpected all variable

self.Manager.SetCurrentEntry(idxTrashVariables, subidx + 1, typeidx, "type", None, self.MasterNode)

# Store the mapping value for this entry

self.TrashVariables[size] = (idxTrashVariables << 16) + ((subidx + 1) << 8) + size

RPDOnumber, TPDOnumber = self.RemoveUsedNodeCobId(self.MasterNode)

# Store the indexes of the first RPDO and TPDO available for MasterNode

self.CurrentPDOParamsIdx = {RPDO : 0x1400 + RPDOnumber, TPDO : 0x1800 + TPDOnumber}

for idx, (nodeid, nodeinfos) in enumerate(self.NodeList.SlaveNodes.items()):

node = nodeinfos["Node"]

node.SetNodeID(nodeid)

RPDOnumber, TPDOnumber = self.RemoveUsedNodeCobId(node)

# Get Slave's default SDO server parameters

RSDO_cobid = node.GetEntry(0x1200,0x01)

if not RSDO_cobid:

TSDO_cobid = node.GetEntry(0x1200,0x02)

if not TSDO_cobid:

TSDO_cobid = 0x580 + nodeid

# Configure Master's SDO parameters entries

self.Manager.ManageEntriesOfCurrent([0x1280 + idx], [], self.MasterNode)

self.MasterNode.SetEntry(0x1280 + idx, 0x01, RSDO_cobid)

self.MasterNode.SetEntry(0x1280 + idx, 0x02, TSDO_cobid)

def GetMasterNode(self):

"""

Return MasterNode.

"""

return self.MasterNode

def AddParamsToDCF(self, nodeid, data, nbparams):

"""

Add entry to DCF, for the requested nodeID

"""

# Get current DCF for slave

nodeDCF = self.MasterNode.GetEntry(0x1F22, nodeid)

# Extract data and number of params in current DCF

if nodeDCF != None and nodeDCF != '':

tmpnbparams = [i for i in nodeDCF[:4]]

tmpnbparams.reverse()

nbparams += int(''.join(["%2.2x"%ord(i) for i in tmpnbparams]), 16)

data = nodeDCF[4:] + data

# Build new DCF

dcf = LE_to_BE(nbparams, 0x04) + data

# Set new DCF for slave

self.MasterNode.SetEntry(0x1F22, nodeid, dcf)

def GetEmptyPDO(self, nodeid, pdotype, start_index=None):

"""

Search a not configured PDO for a slave

index = PDOTypeBaseIndex[pdotype]

else:

index = start_index

# Search for all PDO possible index until find a configurable PDO

# starting from start_index

while index < PDOTypeBaseIndex[pdotype] + 0x200:

return index, cobid, values[0]

index += 1

return None

def AddPDOMapping(self, nodeid, pdotype, pdoindex, pdocobid, pdomapping, sync_TPDOs):

"""

Record a new mapping request for a slave, and add related slave config to the DCF

@param pdomapping: list od variables to map with PDO

"""

# Add an entry to MasterMapping

"mapping" : [None] + [(loc_infos["type"], name) for name, loc_infos in pdomapping]}

# Return the data to add to DCF

if sync_TPDOs:

return GeneratePDOMappingDCF(pdoindex, pdocobid, 0x01, pdomapping)

else:

return GeneratePDOMappingDCF(pdoindex, pdocobid, 0xFF, pdomapping)

return 0, ""

def GenerateDCF(self, locations, current_location, sync_TPDOs):

"""

Generate Concise DCF of MasterNode for the locations list given

@param current_location: tuple of the located prefixes not to be considered

@param sync_TPDOs: indicate if TPDO must be synchronous

"""

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

# Verify that locations correspond to real slave variables

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

# Get list of locations check if exists and mappables -> put them in IECLocations

for location in locations:

COlocationtype = IECToCOType[location["IEC_TYPE"]]

name = location["NAME"]

if name in self.IECLocations:

if self.IECLocations[name]["type"] != COlocationtype:

else:

# Get only the part of the location that concern this node

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

raise PDOmappingException, _("Bad location size : %s") % str(loc)

elif len(loc) == 2:

continue

direction = location["DIR"]

sizelocation = location["SIZE"]

# Extract and check nodeid

nodeid, index, subindex = loc[:3]

# Check Id is in slave node list

if nodeid not in self.NodeList.SlaveNodes.keys():

raise PDOmappingException, _("Non existing node ID : {a1} (variable {a2})").format(a1 = nodeid, a2 = name)

# Get the model for this node (made from EDS)

node = self.NodeList.SlaveNodes[nodeid]["Node"]

# Extract and check index and subindex

if not node.IsEntry(index, subindex):

msg = _("No such index/subindex ({a1},{a2}) in ID : {a3} (variable {a4})").\

format(a1 = "%x" % index, a2 ="%x" % subindex, a3 = nodeid, a4 = name)

raise PDOmappingException, msg

# Get the entry info

subentry_infos = node.GetSubentryInfos(index, subindex)

# If a PDO mappable

if subentry_infos and subentry_infos["pdo"]:

if sizelocation == "X" and len(loc) > 3:

raise PDOmappingException, msg

else:

numbit = None

if location["IEC_TYPE"] != "BOOL" and subentry_infos["type"] != COlocationtype:

raise PDOmappingException, _("Invalid type \"{a1}\"-> {a2} != {a3} for location \"{a4}\"").\

format(a1 = location["IEC_TYPE"], a2 = COlocationtype, a3 = subentry_infos["type"] , a4 = name)

typeinfos = node.GetEntryInfos(COlocationtype)

self.IECLocations[name] = {"type":COlocationtype, "pdotype":SlavePDOType[direction],

"nodeid": nodeid, "index": index,"subindex": subindex,

else:

raise PDOmappingException, _("Not PDO mappable variable : '{a1}' (ID:{a2},Idx:{a3},sIdx:{a4}))").\

format(a1 = name, a2 = nodeid, a3 = "%x" % index, a4 = "%x" % subindex)

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

# Search for locations already mapped

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

for name, locationinfos in self.IECLocations.items():

node = self.NodeList.SlaveNodes[locationinfos["nodeid"]]["Node"]

# Search if slave has a PDO mapping this locations

result = SearchNodePDOMapping(locationinfos, node)

if result != None:

index, subindex = result

# Get COB ID of the PDO

cobid = self.NodeList.GetSlaveNodeEntry(locationinfos["nodeid"], index - 0x200, 1)

# Add PDO to MasterMapping

if cobid not in self.MasterMapping.keys():

# Verify that PDO transmit type is conform to sync_TPDOs

else:

# Change TransmitType to ASYCHRONE

data, nbparams = GeneratePDOMappingDCF(index - 0x200, cobid, 0xFF, [])

self.AddParamsToDCF(locationinfos["nodeid"], data, nbparams)

mapping = [None]

values = node.GetEntry(index)

# Store the size of each entry mapped in PDO

if value != 0:

mapping.append(value % 0x100)

self.MasterMapping[cobid] = {"type" : InvertPDOType[locationinfos["pdotype"]], "mapping" : mapping}

# Indicate that this PDO entry must be saved

if locationinfos["bit"] is not None:

if not isinstance(self.MasterMapping[cobid]["mapping"][subindex], ListType):

self.MasterMapping[cobid]["mapping"][subindex][locationinfos["bit"]] = (locationinfos["type"], name)

else:

self.MasterMapping[cobid]["mapping"][subindex] = (locationinfos["type"], name)

else:

# Add location to those that haven't been mapped yet

if locationinfos["nodeid"] not in self.LocationsNotMapped.keys():

self.LocationsNotMapped[locationinfos["nodeid"]] = {TPDO : [], RPDO : []}

self.LocationsNotMapped[locationinfos["nodeid"]][locationinfos["pdotype"]].append((name, locationinfos))

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

# Build concise DCF for the others locations

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

for nodeid, locations in self.LocationsNotMapped.items():

node = self.NodeList.SlaveNodes[nodeid]["Node"]

# Initialize number of params and data to add to node DCF

nbparams = 0

dataparams = ""

# Generate the best PDO mapping for each type of PDO

for pdotype in (TPDO, RPDO):

if len(locations[pdotype]) > 0:

data, nbaddedparams = self.AddPDOMapping(nodeid, pdotype, pdoindex, pdocobid, pdomapping, sync_TPDOs)

dataparams += data

nbparams += nbaddedparams

# Add number of params and data to node DCF

self.AddParamsToDCF(nodeid, dataparams, nbparams)

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

# Master Node Configuration

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

# Generate Master's Configuration from informations stored in MasterMapping

for cobid, pdo_infos in self.MasterMapping.items():

# Get next PDO index in MasterNode for this PDO type

current_idx = self.CurrentPDOParamsIdx[pdo_infos["type"]]

# Search if there is already a PDO in MasterNode with this cob id

for idx in GetNodePDOIndexes(self.MasterNode, pdo_infos["type"], True):

if self.MasterNode.GetEntry(idx, 1) == cobid:

current_idx = idx

# Add a PDO to MasterNode if not PDO have been found

if current_idx == self.CurrentPDOParamsIdx[pdo_infos["type"]]:

addinglist = [current_idx, current_idx + 0x200]

self.Manager.ManageEntriesOfCurrent(addinglist, [], self.MasterNode)

self.MasterNode.SetEntry(current_idx, 0x01, cobid)

# Increment the number of PDO for this PDO type

self.CurrentPDOParamsIdx[pdo_infos["type"]] += 1

# Change the transmit type of the PDO

if sync_TPDOs:

self.MasterNode.SetEntry(current_idx, 0x02, 0x01)

else:

self.MasterNode.SetEntry(current_idx, 0x02, 0xFF)

mapping = []

for item in pdo_infos["mapping"]:

if isinstance(item, ListType):

mapping.extend(item)

else:

mapping.append(item)

# Add some subentries to PDO mapping if there is not enough

if len(mapping) > 1:

self.Manager.AddSubentriesToCurrent(current_idx + 0x200, len(mapping) - 1, self.MasterNode)

# Generate MasterNode's PDO mapping

for subindex, variable in enumerate(mapping):

if subindex == 0:

continue

new_index = False

if isinstance(variable, (IntType, LongType)):

# If variable is an integer then variable is unexpected

self.MasterNode.SetEntry(current_idx + 0x200, subindex, self.TrashVariables[variable])

else:

typeidx, varname = variable

variable_infos = self.IECLocations[varname]

# Calculate base index for storing variable

mapvariableidx = VariableStartIndex[variable_infos["pdotype"]] + \

VariableTypeOffset[variable_infos["sizelocation"]] * VariableIncrement + \

variable_infos["nodeid"]

# Generate entry name

indexname = "%s%s%s_%d"%(VariableDirText[variable_infos["pdotype"]],

variable_infos["sizelocation"],

'_'.join(map(str,current_location)),

while mapvariableidx < VariableStartIndex[variable_infos["pdotype"]] + 0x2000:

# Entry doesn't exist

# Add entry to MasterNode

self.Manager.AddMapVariableToCurrent(mapvariableidx, "beremiz"+indexname, 3, 1, self.MasterNode)

new_index = True

mapvariableidx += 8 * VariableIncrement

else:

break

# Verify that a not full entry has been found

if mapvariableidx < VariableStartIndex[variable_infos["pdotype"]] + 0x2000:

# Generate subentry name

# Add informations to the new subentry created

self.MasterNode.SetMappingEntry(mapvariableidx, nbsubentries, values = {"name" : subindexname})

self.MasterNode.SetMappingEntry(mapvariableidx, nbsubentries, values = {"type" : typeidx})

# Set value of the PDO mapping

typeinfos = self.Manager.GetEntryInfos(typeidx)

if typeinfos != None:

value = (mapvariableidx << 16) + ((nbsubentries) << 8) + typeinfos["size"]

self.MasterNode.SetEntry(current_idx + 0x200, subindex, value)

# Add variable to pointed variables

self.PointedVariables[(mapvariableidx, nbsubentries)] = "%s_%s"%(indexname, subindexname)

@param nodelist: CanFestival network editor model

@return: a modified copy of the given CanFestival network editor model

"""

dcfgenerator = ConciseDCFGenerator(nodelist, nodename)

dcfgenerator.GenerateDCF(locations, current_location, sync_TPDOs)

masternode,pointers = dcfgenerator.GetMasterNode(), dcfgenerator.GetPointedVariables()

name = location["NAME"]

if name in IECLocations:

if IECLocations[name] != COlocationtype:

else:

# Get only the part of the location that concern this node

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

raise PDOmappingException, _("Bad location size : %s") % str(loc)

elif len(loc) != 2:

continue

# Extract and check nodeid

index, subindex = loc[:2]

# Extract and check index and subindex

if not slave.IsEntry(index, subindex):

raise PDOmappingException, _("No such index/subindex ({a1},{a2}) (variable {a3})").\

format(a1 = "%x" % index, a2 = "%x" % subindex, a3 = name)

# Get the entry info

if subentry_infos["type"] != COlocationtype:

raise PDOmappingException, _("Invalid type \"{a1}\"-> {a2} != {a3} for location \"{a4}\"").\

format( a1 = location["IEC_TYPE"], a2 = COlocationtype, a3 = subentry_infos["type"] , a4 = name)

IECLocations[name] = COlocationtype

pointers[(index, subindex)] = name

return pointers

if __name__ == "__main__":

import os, sys, getopt

Use with caution. Be sure that config_utils

is currently working properly.

"""%sys.argv[0]

# Boolean that indicate if reference result must be redefined

reset = False

base_folder = os.path.split(base_folder)[0]

# Add CanFestival folder to search pathes

sys.path.append(os.path.join(base_folder, "CanFestival-3", "objdictgen"))

from nodemanager import *

from nodelist import *

# Open the test nodelist contained into test_config folder

manager = NodeManager()

nodelist = NodeList(manager)

result = nodelist.LoadProject("test_config")

# List of locations, we try to map for test

locations = [{"IEC_TYPE":"BYTE","NAME":"__IB0_1_64_24576_1","DIR":"I","SIZE":"B","LOC":(0,1,64,24576,1)},

{"IEC_TYPE":"INT","NAME":"__IW0_1_64_25601_2","DIR":"I","SIZE":"W","LOC":(0,1,64,25601,2)},

{"IEC_TYPE":"UDINT","NAME":"__ID0_1_64_25638_3","DIR":"I","SIZE":"D","LOC":(0,1,64,25638,3)},

{"IEC_TYPE":"UDINT","NAME":"__ID0_1_64_25638_4","DIR":"I","SIZE":"D","LOC":(0,1,64,25638,4)},

{"IEC_TYPE":"UDINT","NAME":"__ID0_1_4096_0","DIR":"I","SIZE":"D","LOC":(0,1,4096,0)}]

# Generate MasterNode configuration

try:

masternode, pointedvariables = GenerateConciseDCF(locations, (0, 1), nodelist, True, "TestNode")

except ValueError, message:

print "%s\nTest Failed!"%message

sys.exit()

import pprint

result_node = masternode.PrintString()

result_vars = pprint.pformat(pointedvariables)

result = result_node + "\n********POINTERS*********\n" + result_vars + "\n"

# If reset has been choosen

if reset:

# Write Text into reference result file

testfile = open("test_config/result.txt", "w")

testfile.write(result)

testfile.close()

print "Reset Successful!"

else:

import os

testfile = open("test_config/result_tmp.txt", "w")

testfile.write(result)

testfile.close()

os.system("diff test_config/result.txt test_config/result_tmp.txt")

os.remove("test_config/result_tmp.txt")

"""

class CustomToolTip(wx.PopupWindow):

def __init__(self, parent, tip, restricted=True):

"""

Constructor

@param parent: Parent window

@param tip: Tip text (may be multiline)

characters number defined (default True)

"""

wx.PopupWindow.__init__(self, parent)

self.Restricted = restricted

self.SetBackgroundStyle(wx.BG_STYLE_CUSTOM)

self.SetTip(tip)

# Initialize text font style

self.Font = wx.Font(

faceName = faces["mono"])

self.Bind(wx.EVT_PAINT, self.OnPaint)

def SetFont(self, font):

"""

Set tool tip text font style

"""

self.Font = font

self.RefreshTip()

def SetTip(self, tip):

"""

Set tool tip text

self.Tip.append(new_line)

else:

self.Tip.append(line)

# Restrict number of lines

if len(self.Tip) > TOOLTIP_MAX_LINE:

self.Tip = self.Tip[:TOOLTIP_MAX_LINE]

# Add ... to the end of last line to indicate that tool tip

# text is too long

if len(self.Tip[-1]) < TOOLTIP_MAX_CHARACTERS - 3:

[:TOOLTIP_MAX_CHARACTERS - 3] + "..."

else:

self.Tip = tip.splitlines()

# Prevent to call wx method in non-wx threads

wx.CallAfter(self.RefreshTip)

def SetToolTipPosition(self, pos):

"""

Set tool tip position

"""

# Get screen size to prevent tool tip to go out of the screen

screen_width, screen_height = wx.GetDisplaySize()

# Calculate position of tool tip to stay in screen limits

tip_width, tip_height = self.GetToolTipSize()

self.SetPosition(wx.Point(

max(0, min(pos.x, screen_width - tip_width)),