1 #!/usr/bin/env python

     2 # -*- coding: utf-8 -*-

     3 import shutil

     4 import socket

     5 

     6 __version__ = "$Revision$"

     7 

     8 import os, sys, getopt, wx, tempfile

     9 import __builtin__

    10 from types import TupleType, StringType, UnicodeType

    11 

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

    13 

    14 def Bpath(*args):

    15     return os.path.join(CWD,*args)

    16 

    17 if __name__ == '__main__':

    18     def usage():

    19         print "\nUsage of LPCBeremiz.py :"

    20         print "\n   %s Projectpath Buildpath port\n"%sys.argv[0]

    21     

    22     try:

    23         opts, args = getopt.getopt(sys.argv[1:], "h", ["help"])

    24     except getopt.GetoptError:

    25         # print help information and exit:

    26         usage()

    27         sys.exit(2)

    28     

    29     for o, a in opts:

    30         if o in ("-h", "--help"):

    31             usage()

    32             sys.exit()

    33     

    34     if len(args) != 3:

    35         usage()

    36         sys.exit()

    37     else:

    38         projectOpen = args[0]

    39         buildpath = args[1]

    40         try:

    41             port = int(args[2])

    42         except:

    43             usage()

    44             sys.exit()

    45 

    46     if os.path.exists("LPC_DEBUG"):

    47         __builtin__.__dict__["BMZ_DBG"] = True

    48     else :

    49         __builtin__.__dict__["BMZ_DBG"] = False

    50 

    51 app = wx.PySimpleApp(redirect=BMZ_DBG)

    52 app.SetAppName('beremiz')

    53 wx.InitAllImageHandlers()

    54 

    55 # Import module for internationalization

    56 import gettext

    57 

    58 if __name__ == '__main__':

    59     __builtin__.__dict__['_'] = wx.GetTranslation#unicode_translation

    60 

    61 from Beremiz import *

    62 from ProjectController import ProjectController

    63 from ConfigTreeNode import ConfigTreeNode

    64 import connectors

    65 from util import opjimg

    66 from plcopen.structures import LOCATIONDATATYPES

    67 from PLCControler import LOCATION_CONFNODE, LOCATION_MODULE, LOCATION_GROUP,\

    68                          LOCATION_VAR_INPUT, LOCATION_VAR_OUTPUT, LOCATION_VAR_MEMORY

    69 from PLCOpenEditor import IDEFrame, ProjectDialog

    70 

    71 havecanfestival = False

    72 try:

    73     from canfestival import RootClass as CanOpenRootClass

    74     from canfestival.canfestival import _SlaveCTN, _NodeListCTN, NodeManager

    75     havecanfestival = True

    76 except:

    77     havecanfestival = False

    78     

    79 

    80 #-------------------------------------------------------------------------------

    81 #                          CANFESTIVAL CONFNODE HACK

    82 #-------------------------------------------------------------------------------

    83 # from canfestival import canfestival

    84 # class LPC_canfestival_config:

    85 #     def getCFLAGS(self, *args):

    86 #         return ""

    87 # 

    88 #     def getLDFLAGS(self, *args):

    89 #         return ""

    90 #         

    91 # canfestival.local_canfestival_config = LPC_canfestival_config() 

    92 #-------------------------------------------------------------------------------

    93 #                              LPCModule Class

    94 #-------------------------------------------------------------------------------

    95 

    96 LOCATION_TYPES = {"I": LOCATION_VAR_INPUT,

    97                   "Q": LOCATION_VAR_OUTPUT,

    98                   "M": LOCATION_VAR_MEMORY}

    99 

   100 LOCATION_DIRS = dict([(dir, size) for size, dir in LOCATION_TYPES.iteritems()])

   101 

   102 LOCATION_SIZES = {}

   103 for size, types in LOCATIONDATATYPES.iteritems():

   104     for type in types:

   105         LOCATION_SIZES[type] = size

   106 

   107 def _GetModuleChildren(module):

   108     children = []

   109     for child in module["children"]:

   110         if child["type"] == LOCATION_GROUP:

   111             children.extend(child["children"])

   112         else:

   113             children.append(child)

   114     return children

   115 

   116 def _GetVariables(module):

   117     variables = []

   118     for child in module["children"]:

   119         if child["type"] in [LOCATION_GROUP, LOCATION_MODULE]:

   120             variables.extend(_GetVariables(child))

   121         else:

   122             variables.append(child)

   123     return variables

   124 

   125 def _GetLastModuleGroup(module):

   126     group = module

   127     for child in module["children"]:

   128         if child["type"] == LOCATION_GROUP:

   129             group = child

   130     return group["children"]

   131 

   132 def _GetModuleBySomething(module, something, toks):

   133     for child in _GetModuleChildren(module):

   134         if child.get(something) == toks[0]:

   135             if len(toks) > 1:

   136                 return _GetModuleBySomething(child, something, toks[1:])

   137             return child

   138     return None

   139 

   140 def _GetModuleVariable(module, location, direction):

   141     for child in _GetModuleChildren(module):

   142         if child["location"] == location and child["type"] == LOCATION_TYPES[direction]:

   143             return child

   144     return None

   145 

   146 def _RemoveModuleChild(module, child):

   147     if child in module["children"]:

   148         module["children"].remove(child)

   149     else:

   150         for group in module["children"]:

   151             if group["type"] == LOCATION_GROUP and child in group["children"]:

   152                 group["children"].remove(child)

   153 

   154 BUS_TEXT = """/* Code generated by LPCBus confnode */

   155 

   156 /* LPCBus confnode includes */

   157 #include "app_glue.h"

   158 #ifdef _WINDOWS_H

   159   #include "iec_types.h"

   160 #else

   161   #include "iec_std_lib.h"

   162 #endif

   163 

   164 %(declare_code)s

   165 

   166 /* LPCBus confnode user variables definition */

   167 %(var_decl)s

   168 

   169 /* LPCBus confnode functions */

   170 int __init_%(location_str)s(int argc,char **argv)

   171 {

   172 %(init_code)s

   173   return 0;

   174 }

   175 

   176 void __cleanup_%(location_str)s(void)

   177 {

   178 }

   179 

   180 void __retrieve_%(location_str)s(void)

   181 {

   182 %(retrieve_code)s

   183 }

   184         

   185 void __publish_%(location_str)s(void)

   186 {

   187 %(publish_code)s

   188 }

   189 """

   190 

   191 class LPCBus(object):

   192     

   193     def __init__(self):

   194         self.VariableLocationTree = []

   195         self.ResetUsedLocations()

   196         self.Icon = None

   197     

   198     def __getitem__(self, key):

   199         if key == "children":

   200             return self.VariableLocationTree

   201         raise KeyError, "Only 'children' key is available"

   202     

   203     def CTNEnabled(self):

   204         return None

   205     

   206     def SetIcon(self, icon):

   207         self.Icon = icon

   208     

   209     def _GetChildBySomething(self, something, toks):

   210         return _GetModuleBySomething({"children" : self.VariableLocationTree}, something, toks)

   211     

   212     def GetBaseTypes(self):

   213         return self.GetCTRoot().GetBaseTypes()

   214 

   215     def GetSizeOfType(self, type):

   216         return LOCATION_SIZES[self.GetCTRoot().GetBaseType(type)]

   217     

   218     def _GetVariableLocationTree(self, current_location, infos):

   219         if infos["type"] == LOCATION_MODULE:

   220             location = current_location + (infos["IEC_Channel"],)

   221             return {"name": infos["name"],

   222                     "type": infos["type"],

   223                     "location": ".".join(map(str, location + ("x",))), 

   224                     "icon": infos["icon"], 

   225                     "children": [self._GetVariableLocationTree(location, child) for child in infos["children"]]}

   226         elif infos["type"] == LOCATION_GROUP:

   227             return {"name": infos["name"],

   228                     "type": infos["type"],

   229                     "location": "", 

   230                     "icon": infos["icon"], 

   231                     "children": [self._GetVariableLocationTree(current_location, child) for child in infos["children"]]}

   232         else:

   233             size = self.GetSizeOfType(infos["IEC_type"])

   234             location = "%" + LOCATION_DIRS[infos["type"]] + size + ".".join(map(str, current_location + infos["location"]))

   235             return {"name": infos["name"],

   236                     "type": infos["type"],

   237                     "size": size,

   238                     "IEC_type": infos["IEC_type"],

   239                     "var_name": infos["name"],

   240                     "location": location,

   241                     "description": infos["description"],

   242                     "children": []}

   243     

   244     def GetVariableLocationTree(self):

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

   246                 "type": LOCATION_CONFNODE,

   247                 "location": self.GetFullIEC_Channel(),

   248                 "icon": self.Icon, 

   249                 "children": [self._GetVariableLocationTree(self.GetCurrentLocation(), child) 

   250                              for child in self.VariableLocationTree]}

   251     

   252     def CTNTestModified(self):

   253         return False

   254 

   255     def CTNMakeDir(self):

   256         pass

   257 

   258     def CTNRequestSave(self):

   259         return None

   260 

   261     def ResetUsedLocations(self):

   262         self.UsedLocations = {}

   263     

   264     def _AddUsedLocation(self, parent, location):

   265         num = location.pop(0)

   266         if not parent.has_key(num):

   267             parent[num] = {"used": False, "children": {}}

   268         if len(location) > 0:

   269             self._AddUsedLocation(parent[num]["children"], location)

   270         else:

   271             parent[num]["used"] = True

   272         

   273     def AddUsedLocation(self, location):

   274         if len(location) > 0:

   275             self._AddUsedLocation(self.UsedLocations, list(location))

   276 

   277     def _CheckLocationConflicts(self, parent, location):

   278         num = location.pop(0)

   279         if not parent.has_key(num):

   280             return False

   281         if len(location) > 0:

   282             if parent[num]["used"]:

   283                 return True

   284             return self._CheckLocationConflicts(parent[num]["children"], location)

   285         elif len(parent[num]["children"]) > 0:

   286             return True

   287         return False

   288 

   289     def CheckLocationConflicts(self, location):

   290         if len(location) > 0:

   291             return self._CheckLocationConflicts(self.UsedLocations, list(location))

   292         return False

   293 

   294     def CTNGenerate_C(self, buildpath, locations):

   295         """

   296         Generate C code

   297         @param current_location: Tupple containing confnode IEC location : %I0.0.4.5 => (0,0,4,5)

   298         @param locations: List of complete variables locations \

   299             [{"IEC_TYPE" : the IEC type (i.e. "INT", "STRING", ...)

   300             "NAME" : name of the variable (generally "__IW0_1_2" style)

   301             "DIR" : direction "Q","I" or "M"

   302             "SIZE" : size "X", "B", "W", "D", "L"

   303             "LOC" : tuple of interger for IEC location (0,1,2,...)

   304             }, ...]

   305         @return: [(C_file_name, CFLAGS),...] , LDFLAGS_TO_APPEND

   306         """

   307         current_location = self.GetCurrentLocation()

   308         # define a unique name for the generated C file

   309         location_str = "_".join(map(str, current_location))

   310         

   311         code_str = {"location_str": location_str,

   312                     "var_decl": "",

   313                     "declare_code": "",

   314                     "init_code": "",

   315                     "retrieve_code": "",

   316                     "publish_code": "",

   317                    }

   318         

   319         for module in _GetModuleChildren(self):

   320             if module["init"] != "":

   321                 code_str["init_code"] += "  %s\n" % module["init"]

   322         

   323         # Adding variables

   324         vars = []

   325         self.ResetUsedLocations()

   326         for location in locations:

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

   328             group = next = self

   329             i = 0

   330             while next is not None and i < len(loc):

   331                 next = self._GetChildBySomething("IEC_Channel", loc[:i + 1])

   332                 if next is not None:

   333                     i += 1

   334                     group = next

   335             var_loc = loc[i:]

   336             for variable in _GetModuleChildren(group):

   337                 if variable["location"] == var_loc and location["DIR"] == LOCATION_DIRS[variable["type"]]:

   338 #                    if location["DIR"] != LOCATION_DIRS[variable["type"]]:

   339 #                        raise Exception, "Direction conflict in variable definition"

   340 #                    if location["IEC_TYPE"] != variable["IEC_type"]:

   341 #                        raise Exception, "Type conflict in variable definition"

   342                     if location["DIR"] == "Q":

   343                         if self.CheckLocationConflicts(location["LOC"]):

   344                             raise Exception, "BYTE and BIT from the same BYTE can't be used together"

   345                         self.AddUsedLocation(location["LOC"])

   346                     vars.append({"location": location["NAME"],

   347                                  "Type": variable["IEC_type"],

   348                                  "Retrieve": variable["retrieve"],

   349                                  "Publish": variable["publish"],

   350                                 })

   351                     break

   352         base_types = self.GetCTRoot().GetBaseTypes()

   353         for var in vars:

   354             prefix = ""

   355             if var["Type"] in base_types:

   356                 prefix = "IEC_"

   357             code_str["var_decl"] += "%s%s beremiz%s;\n"%(prefix, var["Type"], var["location"])

   358             code_str["var_decl"] += "%s%s *%s = &beremiz%s;\n"%(prefix, var["Type"], var["location"], var["location"])

   359             if var["Retrieve"] != "":

   360                 code_str["retrieve_code"] += "  " + var["Retrieve"] % ("*" + var["location"]) + "\n"

   361             if var["Publish"] != "":

   362                 code_str["publish_code"] += "  " + var["Publish"] % ("*" + var["location"]) + "\n"

   363         

   364         Gen_Module_path = os.path.join(buildpath, "Bus_%s.c"%location_str)

   365         module = open(Gen_Module_path,'w')

   366         module.write(BUS_TEXT % code_str)

   367         module.close()

   368         

   369         matiec_flags = '"-I%s"'%os.path.abspath(self.GetCTRoot().GetIECLibPath())

   370         return [(Gen_Module_path, matiec_flags)],"",True

   371 

   372 #-------------------------------------------------------------------------------

   373 #                          LPC CanFestival ConfNode Class

   374 #-------------------------------------------------------------------------------

   375 

   376 if havecanfestival:

   377 

   378     DEFAULT_SETTINGS = {

   379         "CAN_Baudrate": "125K",

   380         "Slave_NodeId": 2,

   381         "Master_NodeId": 1,

   382     }

   383     

   384     class LPCCanOpenSlave(_SlaveCTN):

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

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

   387           <xsd:element name="CanFestivalSlaveNode">

   388             <xsd:complexType>

   389               <xsd:attribute name="CAN_Baudrate" type="xsd:string" use="optional" default="%(CAN_Baudrate)s"/>

   390               <xsd:attribute name="NodeId" type="xsd:string" use="optional" default="%(Slave_NodeId)d"/>

   391               <xsd:attribute name="Sync_Align" type="xsd:integer" use="optional" default="0"/>

   392               <xsd:attribute name="Sync_Align_Ratio" use="optional" default="50">

   393                 <xsd:simpleType>

   394                     <xsd:restriction base="xsd:integer">

   395                         <xsd:minInclusive value="1"/>

   396                         <xsd:maxInclusive value="99"/>

   397                     </xsd:restriction>

   398                 </xsd:simpleType>

   399               </xsd:attribute>

   400             </xsd:complexType>

   401           </xsd:element>

   402         </xsd:schema>

   403         """ % DEFAULT_SETTINGS

   404         

   405         def __init__(self):

   406             # TODO change netname when name change

   407             NodeManager.__init__(self)

   408             odfilepath = self.GetSlaveODPath()

   409             if(os.path.isfile(odfilepath)):

   410                 self.OpenFileInCurrent(odfilepath)

   411             else:

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

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

   414                                    "slave",      # Type

   415                                    "",           # description 

   416                                    "None",       # profile

   417                                    "", # prfile filepath

   418                                    "heartbeat",  # NMT

   419                                    [])           # options

   420                 self.OnCTNSave()

   421         

   422         def GetCanDevice(self):

   423             return str(self.BaseParams.getIEC_Channel())

   424         

   425     class LPCCanOpenMaster(_NodeListCTN):

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

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

   428           <xsd:element name="CanFestivalNode">

   429             <xsd:complexType>

   430               <xsd:attribute name="CAN_Baudrate" type="xsd:string" use="optional" default="%(CAN_Baudrate)s"/>

   431               <xsd:attribute name="NodeId" type="xsd:string" use="optional" default="%(Master_NodeId)d"/>

   432               <xsd:attribute name="Sync_TPDOs" type="xsd:boolean" use="optional" default="true"/>

   433             </xsd:complexType>

   434           </xsd:element>

   435         </xsd:schema>

   436         """ % DEFAULT_SETTINGS

   437     

   438         def GetCanDevice(self):

   439             return str(self.BaseParams.getIEC_Channel())

   440     

   441     class LPCCanOpen(CanOpenRootClass):

   442         XSD = None

   443         CTNChildrenTypes = [("CanOpenNode",LPCCanOpenMaster, "CanOpen Master"),

   444                            ("CanOpenSlave",LPCCanOpenSlave, "CanOpen Slave")]

   445         

   446         def GetCanDriver(self):

   447             return ""

   448         

   449         def LoadChildren(self):

   450             ConfigTreeNode.LoadChildren(self)

   451             

   452             if self.GetChildByName("Master") is None:

   453                 master = self.CTNAddChild("Master", "CanOpenNode", 0)

   454                 master.BaseParams.setEnabled(False)

   455             

   456             if self.GetChildByName("Slave") is None:

   457                 slave = self.CTNAddChild("Slave", "CanOpenSlave", 1)

   458                 slave.BaseParams.setEnabled(False)

   459     

   460 

   461 #-------------------------------------------------------------------------------

   462 #                              LPCProjectController Class

   463 #-------------------------------------------------------------------------------

   464 

   465 def mycopytree(src, dst):

   466     """

   467     Copy content of a directory to an other, omit hidden files

   468     @param src: source directory

   469     @param dst: destination directory

   470     """

   471     for i in os.listdir(src):

   472         if not i.startswith('.') and i != "pous.xml":

   473             srcpath = os.path.join(src,i)

   474             dstpath = os.path.join(dst,i)

   475             if os.path.isdir(srcpath):

   476                 if os.path.exists(dstpath):

   477                     shutil.rmtree(dstpath)

   478                 os.makedirs(dstpath)

   479                 mycopytree(srcpath, dstpath)

   480             elif os.path.isfile(srcpath):

   481                 shutil.copy2(srcpath, dstpath)

   482 

   483 [SIMULATION_MODE, TRANSFER_MODE] = range(2)

   484 

   485 class LPCProjectController(ProjectController):

   486 

   487     ConfNodeMethods = [

   488         {"bitmap" : opjimg("Debug"),

   489          "name" : _("Simulate"),

   490          "tooltip" : _("Simulate PLC"),

   491          "method" : "_Simulate"},

   492         {"bitmap" : opjimg("Run"),

   493          "name" : _("Run"),

   494          "shown" : False,

   495          "tooltip" : _("Start PLC"),

   496          "method" : "_Run"},

   497         {"bitmap" : opjimg("Stop"),

   498          "name" : _("Stop"),

   499          "shown" : False,

   500          "tooltip" : _("Stop Running PLC"),

   501          "method" : "_Stop"},

   502         {"bitmap" : opjimg("Build"),

   503          "name" : _("Build"),

   504          "tooltip" : _("Build project into build folder"),

   505          "method" : "_Build"},

   506         {"bitmap" : opjimg("Transfer"),

   507          "name" : _("Transfer"),

   508          "shown" : False,

   509          "tooltip" : _("Transfer PLC"),

   510          "method" : "_Transfer"},

   511     ]

   512 

   513     def __init__(self, frame, logger, buildpath):

   514         self.OrigBuildPath = buildpath

   515         

   516         ProjectController.__init__(self, frame, logger)

   517         

   518         if havecanfestival:

   519             self.CTNChildrenTypes += [("LPCBus", LPCBus, "LPC bus"), ("CanOpen", LPCCanOpen, "CanOpen bus")]

   520         else:

   521             self.CTNChildrenTypes += [("LPCBus", LPCBus, "LPC bus")]

   522         self.CTNType = "LPC"

   523         

   524         self.OnlineMode = "OFF"

   525         self.LPCConnector = None

   526         

   527         self.CurrentMode = None

   528         self.previous_mode = None

   529         

   530         self.SimulationBuildPath = None

   531         

   532         self.AbortTransferTimer = None

   533     

   534     def ConfNodeLibraryFilePath(self):

   535         if self.OrigBuildPath is not None:

   536             return os.path.join(self.OrigBuildPath, "pous.xml")

   537         else:

   538             return ProjectController.ConfNodeLibraryFilePath(self)

   539     

   540     def GetProjectName(self):

   541         return self.Project.getname()

   542 

   543     def GetDefaultTargetName(self):

   544         if self.CurrentMode == SIMULATION_MODE:

   545             return ProjectController.GetDefaultTargetName(self)

   546         else:

   547             return "LPC"

   548 

   549     def GetTarget(self):

   550         target = ProjectController.GetTarget(self)

   551         if self.CurrentMode != SIMULATION_MODE:

   552             target.getcontent()["value"].setBuildPath(self.BuildPath)

   553         return target

   554     

   555     def _getBuildPath(self):

   556         if self.CurrentMode == SIMULATION_MODE:

   557             if self.SimulationBuildPath is None:

   558                 self.SimulationBuildPath = os.path.join(tempfile.mkdtemp(), os.path.basename(self.ProjectPath), "build")

   559             return self.SimulationBuildPath

   560         else:

   561             return ProjectController._getBuildPath(self)

   562 

   563     def _Build(self):

   564         save = self.ProjectTestModified()

   565         if save:

   566             self.SaveProject()

   567             self.AppFrame._Refresh(TITLE, FILEMENU)

   568         if self.BuildPath is not None:

   569             mycopytree(self.OrigBuildPath, self.BuildPath)

   570         ProjectController._Build(self)

   571         if save:

   572             wx.CallAfter(self.AppFrame.RefreshAll)

   573     

   574     def SetProjectName(self, name):

   575         return self.Project.setname(name)

   576 

   577     def SetOnlineMode(self, mode, path=None):

   578         if self.OnlineMode != mode.upper():

   579             self.OnlineMode = mode.upper()

   580             

   581             if self.OnlineMode != "OFF":

   582                 uri = "LPC://%s/%s" % (self.OnlineMode,path)

   583                 try:

   584                     self.LPCConnector = connectors.ConnectorFactory(uri, self)

   585                 except Exception, msg:

   586                     self.logger.write_error(_("Exception while connecting %s!\n")%uri)

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

   588 

   589                 # Did connection success ?

   590                 if self.LPCConnector is None:

   591                     # Oups.

   592                     self.logger.write_error(_("Connection failed to %s!\n")%uri)

   593                 

   594             else:

   595                 self.LPCConnector = None

   596             

   597             self.ApplyOnlineMode()

   598 

   599     def ApplyOnlineMode(self):

   600         if self.CurrentMode != SIMULATION_MODE:

   601             self.KillDebugThread()

   602             

   603             self._connector = self.LPCConnector

   604             

   605             # Init with actual PLC status and print it

   606             self.UpdateMethodsFromPLCStatus()

   607                 

   608             if self.LPCConnector is not None and self.OnlineMode == "APPLICATION":

   609                 

   610                 self.CompareLocalAndRemotePLC()

   611                             

   612                 if self.previous_plcstate is not None:

   613                     status = _(self.previous_plcstate)

   614                 else:

   615                     status = ""

   616                 self.logger.write(_("PLC is %s\n")%status)

   617                 

   618                 #if self.StatusTimer and not self.StatusTimer.IsRunning():

   619                 #    # Start the status Timer

   620                 #    self.StatusTimer.Start(milliseconds=2000, oneShot=False)

   621                 

   622                 if self.previous_plcstate=="Started":

   623                     if self.DebugAvailable() and self.GetIECProgramsAndVariables():

   624                         self.logger.write(_("Debug connect matching running PLC\n"))

   625                         self._connect_debug()

   626                     else:

   627                         self.logger.write_warning(_("Debug do not match PLC - stop/transfert/start to re-enable\n"))

   628             

   629             elif self.StatusTimer and self.StatusTimer.IsRunning():

   630                 self.StatusTimer.Stop()

   631             

   632             if self.CurrentMode == TRANSFER_MODE:

   633                 

   634                 if self.OnlineMode == "BOOTLOADER":

   635                     self.BeginTransfer()

   636                 

   637                 elif self.OnlineMode == "APPLICATION":

   638                     self.CurrentMode = None

   639                     self.AbortTransferTimer.Stop()

   640                     self.AbortTransferTimer = None

   641                     

   642                     self.logger.write(_("PLC transferred successfully\n"))

   643     

   644     # Update a PLCOpenEditor Pou variable name

   645     def UpdateProjectVariableName(self, old_name, new_name):

   646         self.Project.updateElementName(old_name, new_name)

   647         self.BufferProject()

   648 

   649     def RemoveProjectVariableByAddress(self, address):

   650         self.Project.removeVariableByAddress(address)

   651         self.BufferProject()

   652 

   653     def RemoveProjectVariableByFilter(self, leading):

   654         self.Project.removeVariableByFilter(leading)

   655         self.BufferProject()

   656 

   657     def LoadProject(self, ProjectPath, BuildPath=None):

   658         """

   659         Load a project contained in a folder

   660         @param ProjectPath: path of the project folder

   661         """

   662         if os.path.basename(ProjectPath) == "":

   663             ProjectPath = os.path.dirname(ProjectPath)

   664         

   665         # Verify that project contains a PLCOpen program

   666         plc_file = os.path.join(ProjectPath, "plc.xml")

   667         if os.path.isfile(plc_file):

   668             # Load PLCOpen file

   669             result = self.OpenXMLFile(plc_file)

   670             if result:

   671                 return result

   672         else:

   673             self.CreateNewProject({"companyName": "",

   674                                    "productName": "",

   675                                    "productVersion": "",

   676                                    "projectName": "",

   677                                    "pageSize": (0, 0),

   678                                    "scaling": {}})

   679         

   680         # Change XSD into class members

   681         self._AddParamsMembers()

   682         self.Children = {}

   683         

   684         # Keep track of the root confnode (i.e. project path)

   685         self.ProjectPath = ProjectPath

   686         

   687         self.BuildPath = self._getBuildPath()

   688         if self.OrigBuildPath is not None:

   689             mycopytree(self.OrigBuildPath, self.BuildPath)

   690         

   691         # If dir have already be made, and file exist

   692         if os.path.isdir(self.CTNPath()) and os.path.isfile(self.ConfNodeXmlFilePath()):

   693             #Load the confnode.xml file into parameters members

   694             result = self.LoadXMLParams()

   695             if result:

   696                 return result

   697             #Load and init all the children

   698             self.LoadChildren()

   699         

   700         if havecanfestival and self.GetChildByName("CanOpen") is None:

   701             canopen = self.CTNAddChild("CanOpen", "CanOpen", 0)

   702             canopen.BaseParams.setEnabled(False)

   703             canopen.LoadChildren()

   704         

   705         if self.CTNTestModified():

   706             self.SaveProject()

   707         

   708         if wx.GetApp() is None:

   709             self.RefreshConfNodesBlockLists()

   710         else:

   711             wx.CallAfter(self.RefreshConfNodesBlockLists)

   712 

   713         return None

   714 

   715     ############# Real PLC object access #############

   716     def UpdateMethodsFromPLCStatus(self):

   717         # Get PLC state : Running or Stopped

   718         # TODO : use explicit status instead of boolean

   719         if self.OnlineMode == "OFF":

   720             status = "Disconnected"

   721         elif self.OnlineMode == "BOOTLOADER":

   722             status = "Connected"

   723         else:

   724             if self._connector is not None:

   725                 status = self._connector.GetPLCstatus()

   726             else:

   727                 status = "Disconnected"

   728         if self.previous_plcstate != status or self.previous_mode != self.CurrentMode:

   729             simulating = self.CurrentMode == SIMULATION_MODE

   730             for args in {

   731                      "Started" :     [("_Simulate", False),

   732                                       ("_Run", False),

   733                                       ("_Stop", True),

   734                                       ("_Build", True),

   735                                       ("_Transfer", True)],

   736                      "Stopped" :     [("_Simulate", False),

   737                                       ("_Run", True),

   738                                       ("_Stop", False),

   739                                       ("_Build", True),

   740                                       ("_Transfer", True)],

   741                      "Connected" :   [("_Simulate", not simulating),

   742                                       ("_Run", True),

   743                                       ("_Stop", simulating),

   744                                       ("_Build", True),

   745                                       ("_Transfer", True)],

   746                      "Disconnected" :[("_Simulate", not simulating),

   747                                       ("_Run", False),

   748                                       ("_Stop", simulating),

   749                                       ("_Build", True),

   750                                       ("_Transfer", False)],

   751                    }.get(status,[]):

   752                 self.ShowMethod(*args)

   753             self.previous_plcstate = status

   754             self.previous_mode = self.CurrentMode

   755             return True

   756         return False

   757 

   758     def Generate_plc_declare_locations(self):

   759         """

   760         Declare used locations in order to simulatePLC in a black box

   761         """

   762         return """#include "iec_types_all.h"

   763 

   764 #define __LOCATED_VAR(type, name, ...) \

   765 type beremiz_##name;\

   766 type *name = &beremiz_##name;

   767 

   768 #include "LOCATED_VARIABLES.h"

   769 

   770 #undef __LOCATED_VAR

   771 

   772 """

   773 

   774     def Generate_lpc_retain_array_sim(self):

   775         """

   776         Support for retain array in Simulation

   777         """

   778         return """/* Support for retain array */

   779 #define USER_RETAIN_ARRAY_SIZE 2000

   780 #define NUM_OF_COLS    3

   781 unsigned char readOK = 0;

   782 unsigned int foundIndex = USER_RETAIN_ARRAY_SIZE;

   783 unsigned int retainArray[USER_RETAIN_ARRAY_SIZE][NUM_OF_COLS];

   784 

   785 unsigned int __GetRetainData(unsigned char READ, unsigned int INDEX, unsigned int COLUMN)

   786 {

   787     if(READ == 1)

   788     {

   789         if((0<=INDEX) && (INDEX<USER_RETAIN_ARRAY_SIZE) && (0<=COLUMN) && (COLUMN<NUM_OF_COLS))

   790         {

   791             readOK = 1;

   792             return retainArray[INDEX][COLUMN];

   793         }

   794     }

   795 

   796     readOK = 0;

   797     return 0;

   798 }

   799 

   800 unsigned char __SetRetainData(unsigned char WRITE, unsigned int INDEX, unsigned int WORD1, unsigned int WORD2, unsigned int WORD3)

   801 {

   802     if(WRITE == 1)

   803     {

   804         if((0<=INDEX) && (INDEX<USER_RETAIN_ARRAY_SIZE))

   805         {

   806             retainArray[INDEX][0] = WORD1;

   807             retainArray[INDEX][1] = WORD2;

   808             retainArray[INDEX][2] = WORD3;

   809             return 1;

   810         }

   811     }

   812     

   813     return 0;

   814 }

   815 

   816 unsigned char __FindRetainData(unsigned char SEARCH, unsigned int START_IDX, unsigned int END_IDX, unsigned int WORD1, unsigned int WORD2, unsigned int WORD3)

   817 {

   818     unsigned int i;

   819 

   820     if((SEARCH==1) && (0<=START_IDX) && (START_IDX<USER_RETAIN_ARRAY_SIZE) && (START_IDX<=END_IDX) && (END_IDX<USER_RETAIN_ARRAY_SIZE))

   821     {

   822         for(i=START_IDX;i<=END_IDX;i++)

   823         {

   824             if((retainArray[i][0] == WORD1) && (retainArray[i][1] == WORD2) && (retainArray[i][2] == WORD3))

   825             {

   826                 foundIndex = i;

   827                 return 1;

   828             }

   829         }

   830     }

   831 

   832     foundIndex = USER_RETAIN_ARRAY_SIZE;    /* Data not found => return index that is out of array bounds */

   833     return 0;

   834 }

   835 

   836 /* Since Beremiz debugger doesn't like pointer-by-reference stuff or global varibles, separate function is a must */

   837 unsigned char __GetReadStatus(unsigned char dummy)

   838 {

   839     return readOK;

   840 }

   841 

   842 unsigned int __GetFoundIndex(unsigned char dummy)

   843 {

   844     return foundIndex;

   845 }

   846 """

   847 

   848     def _Simulate(self):

   849         """

   850         Method called by user to Simulate PLC

   851         """

   852         self.CurrentMode = SIMULATION_MODE

   853         

   854         uri = "LOCAL://"

   855         try:

   856             self._connector = connectors.ConnectorFactory(uri, self)

   857         except Exception, msg:

   858             self.logger.write_error(_("Exception while connecting %s!\n")%uri)

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

   860 

   861         # Did connection success ?

   862         if self._connector is None:

   863             # Oups.

   864             self.logger.write_error(_("Connection failed to %s!\n")%uri)

   865             self.StopSimulation()

   866             return False

   867         

   868         buildpath = self._getBuildPath()

   869         

   870         # Eventually create build dir

   871         if not os.path.exists(buildpath):

   872             os.makedirs(buildpath)

   873         

   874         # Generate SoftPLC IEC code

   875         IECGenRes = self._Generate_SoftPLC()

   876         

   877          # If IEC code gen fail, bail out.

   878         if not IECGenRes:

   879             self.logger.write_error(_("IEC-61131-3 code generation failed !\n"))

   880             self.StopSimulation()

   881             return False

   882 

   883         # Reset variable and program list that are parsed from

   884         # CSV file generated by IEC2C compiler.

   885         self.ResetIECProgramsAndVariables()

   886         

   887         gen_result = self.CTNGenerate_C(buildpath, self.PLCGeneratedLocatedVars)

   888         CTNCFilesAndCFLAGS, CTNLDFLAGS, DoCalls = gen_result[:3]

   889         # if some files have been generated put them in the list with their location

   890         if CTNCFilesAndCFLAGS:

   891             self.LocationCFilesAndCFLAGS = [(self.GetCurrentLocation(), CTNCFilesAndCFLAGS, DoCalls)]

   892         else:

   893             self.LocationCFilesAndCFLAGS = []

   894 

   895         # confnode asks for some LDFLAGS

   896         if CTNLDFLAGS:

   897             # LDFLAGS can be either string

   898             if type(CTNLDFLAGS)==type(str()):

   899                 self.LDFLAGS=[CTNLDFLAGS]

   900             #or list of strings

   901             elif type(CTNLDFLAGS)==type(list()):

   902                 self.LDFLAGS=CTNLDFLAGS[:]

   903         else:

   904             self.LDFLAGS=[]

   905         

   906         # Template based part of C code generation

   907         # files are stacked at the beginning, as files of confnode tree root

   908         for generator, filename, name in [

   909            # debugger code

   910            (self.Generate_plc_debugger, "plc_debugger.c", "Debugger"),

   911            # init/cleanup/retrieve/publish, run and align code

   912            (self.Generate_plc_common_main,"plc_common_main.c","Common runtime"),

   913            # declare located variables for simulate in a black box

   914            (self.Generate_plc_declare_locations,"plc_declare_locations.c","Declare Locations"),

   915            # declare located variables for simulate in a black box

   916            (self.Generate_lpc_retain_array_sim,"lpc_retain_array_sim.c","Retain Array for Simulation")]:

   917             try:

   918                 # Do generate

   919                 code = generator()

   920                 if code is None:

   921                      raise

   922                 code_path = os.path.join(buildpath,filename)

   923                 open(code_path, "w").write(code)

   924                 # Insert this file as first file to be compiled at root confnode

   925                 self.LocationCFilesAndCFLAGS[0][1].insert(0,(code_path, self.plcCFLAGS))

   926             except Exception, exc:

   927                 self.logger.write_error(name+_(" generation failed !\n"))

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

   929                 self.StopSimulation()

   930                 return False

   931         

   932         # Get simulation builder

   933         builder = self.GetBuilder()

   934         if builder is None:

   935             self.logger.write_error(_("Fatal : cannot get builder.\n"))

   936             self.StopSimulation()

   937             return False

   938 

   939         # Build

   940         try:

   941             if not builder.build() :

   942                 self.logger.write_error(_("C Build failed.\n"))

   943                 self.StopSimulation()

   944                 return False

   945         except Exception, exc:

   946             self.logger.write_error(_("C Build crashed !\n"))

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

   948             self.StopSimulation()

   949             return False

   950 

   951         data = builder.GetBinaryCode()

   952         if data is not None :

   953             if self._connector.NewPLC(builder.GetBinaryCodeMD5(), data, []):

   954                 self.UnsubscribeAllDebugIECVariable()

   955                 self.ProgramTransferred()

   956                 if self.AppFrame is not None:

   957                     self.AppFrame.CloseObsoleteDebugTabs()

   958                 self.logger.write(_("Transfer completed successfully.\n"))

   959             else:

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

   961                 self.StopSimulation()

   962                 return False

   963         

   964         self._Run()

   965                 

   966         if not self.StatusTimer.IsRunning():

   967             # Start the status Timer

   968             self.StatusTimer.Start(milliseconds=500, oneShot=False)

   969     

   970     def StopSimulation(self):

   971         self.CurrentMode = None

   972         self.ApplyOnlineMode()

   973     

   974     def _Stop(self):

   975         ProjectController._Stop(self)

   976         

   977         if self.CurrentMode == SIMULATION_MODE:

   978             self.StopSimulation()

   979 

   980     def CompareLocalAndRemotePLC(self):

   981         if self.LPCConnector is None:

   982             return

   983         # We are now connected. Update button status

   984         MD5 = self.GetLastBuildMD5()

   985         # Check remote target PLC correspondance to that md5

   986         if MD5 is not None and self.LPCConnector.MatchMD5(MD5):

   987             # warns controller that program match

   988             self.ProgramTransferred()

   989 

   990     def ResetBuildMD5(self):

   991         builder=self.GetBuilder()

   992         if builder is not None:

   993             builder.ResetBinaryCodeMD5(self.OnlineMode)

   994         

   995     def GetLastBuildMD5(self):

   996         builder=self.GetBuilder()

   997         if builder is not None:

   998             return builder.GetBinaryCodeMD5(self.OnlineMode)

   999         else:

  1000             return None

  1001 

  1002     def _Transfer(self):

  1003         if self.CurrentMode is None and self.OnlineMode != "OFF":

  1004             self.CurrentMode = TRANSFER_MODE

  1005             

  1006             if ProjectController._Build(self):

  1007             

  1008                 ID_ABORTTRANSFERTIMER = wx.NewId()

  1009                 self.AbortTransferTimer = wx.Timer(self.AppFrame, ID_ABORTTRANSFERTIMER)

  1010                 self.AppFrame.Bind(wx.EVT_TIMER, self.AbortTransfer, self.AbortTransferTimer)  

  1011                 

  1012                 if self.OnlineMode == "BOOTLOADER":

  1013                     self.BeginTransfer()

  1014                 

  1015                 else:

  1016                     self.logger.write(_("Resetting PLC\n"))

  1017                     #self.StatusTimer.Stop()

  1018                     self.LPCConnector.ResetPLC()

  1019                     self.AbortTransferTimer.Start(milliseconds=5000, oneShot=True)

  1020             

  1021             else:

  1022                 self.CurrentMode = None

  1023     

  1024     def BeginTransfer(self):

  1025         self.logger.write(_("Start PLC transfer\n"))

  1026         

  1027         self.AbortTransferTimer.Stop()

  1028         ProjectController._Transfer(self)

  1029         self.AbortTransferTimer.Start(milliseconds=5000, oneShot=True)

  1030     

  1031     def AbortTransfer(self, event):

  1032         self.logger.write_warning(_("Timeout waiting PLC to recover\n"))

  1033         

  1034         self.CurrentMode = None

  1035         self.AbortTransferTimer.Stop()

  1036         self.AbortTransferTimer = None

  1037         event.Skip()

  1038 

  1039     def _Run(self):

  1040         """

  1041         Start PLC

  1042         """

  1043         if self.GetIECProgramsAndVariables():

  1044             self._connector.StartPLC()

  1045             self.logger.write(_("Starting PLC\n"))

  1046             self._connect_debug()

  1047         else:

  1048             self.logger.write_error(_("Couldn't start PLC !\n"))

  1049         self.UpdateMethodsFromPLCStatus()

  1050 

  1051 #-------------------------------------------------------------------------------

  1052 #                              LPCBeremiz Class

  1053 #-------------------------------------------------------------------------------

  1054 lpcberemiz_cmd=None

  1055 

  1056 class LPCBeremiz(Beremiz):

  1057     

  1058     def _init_coll_FileMenu_Items(self, parent):

  1059         AppendMenu(parent, help='', id=wx.ID_SAVE,

  1060               kind=wx.ITEM_NORMAL, text=_(u'Save\tCTRL+S'))

  1061         AppendMenu(parent, help='', id=wx.ID_CLOSE,

  1062               kind=wx.ITEM_NORMAL, text=_(u'Close Tab\tCTRL+W'))

  1063         parent.AppendSeparator()

  1064         AppendMenu(parent, help='', id=wx.ID_PAGE_SETUP,

  1065               kind=wx.ITEM_NORMAL, text=_(u'Page Setup'))

  1066         AppendMenu(parent, help='', id=wx.ID_PREVIEW,

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

  1068         AppendMenu(parent, help='', id=wx.ID_PRINT,

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

  1070         parent.AppendSeparator()

  1071         AppendMenu(parent, help='', id=wx.ID_PROPERTIES,

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

  1073         parent.AppendSeparator()

  1074         AppendMenu(parent, help='', id=wx.ID_EXIT,

  1075               kind=wx.ITEM_NORMAL, text=_(u'Quit\tCTRL+Q'))

  1076         

  1077         self.Bind(wx.EVT_MENU, self.OnSaveProjectMenu, id=wx.ID_SAVE)

  1078         self.Bind(wx.EVT_MENU, self.OnCloseTabMenu, id=wx.ID_CLOSE)

  1079         self.Bind(wx.EVT_MENU, self.OnPageSetupMenu, id=wx.ID_PAGE_SETUP)

  1080         self.Bind(wx.EVT_MENU, self.OnPreviewMenu, id=wx.ID_PREVIEW)

  1081         self.Bind(wx.EVT_MENU, self.OnPrintMenu, id=wx.ID_PRINT)

  1082         self.Bind(wx.EVT_MENU, self.OnPropertiesMenu, id=wx.ID_PROPERTIES)

  1083         self.Bind(wx.EVT_MENU, self.OnQuitMenu, id=wx.ID_EXIT)

  1084     

  1085         self.AddToMenuToolBar([(wx.ID_SAVE, "save.png", _(u'Save'), None),

  1086                                (wx.ID_PRINT, "print.png", _(u'Print'), None)])

  1087     

  1088     def _init_ctrls(self, prnt):

  1089         IDEFrame._init_ctrls(self, prnt)

  1090         

  1091         self.Bind(wx.EVT_MENU, self.OnOpenWidgetInspector, id=ID_BEREMIZINSPECTOR)

  1092         accel = wx.AcceleratorTable([wx.AcceleratorEntry(wx.ACCEL_CTRL|wx.ACCEL_ALT, ord('I'), ID_BEREMIZINSPECTOR)])

  1093         self.SetAcceleratorTable(accel)

  1094         

  1095         self.PLCConfig = wx.ScrolledWindow(id=ID_BEREMIZPLCCONFIG,

  1096               name='PLCConfig', parent=self.LeftNoteBook, pos=wx.Point(0, 0),

  1097               size=wx.Size(-1, -1), style=wx.TAB_TRAVERSAL|wx.SUNKEN_BORDER|wx.HSCROLL|wx.VSCROLL)

  1098         self.PLCConfig.SetBackgroundColour(wx.WHITE)

  1099         self.PLCConfig.Bind(wx.EVT_LEFT_DOWN, self.OnPanelLeftDown)

  1100         self.PLCConfig.Bind(wx.EVT_SIZE, self.OnMoveWindow)

  1101         self.LeftNoteBook.InsertPage(0, self.PLCConfig, _("Topology"), True)

  1102         

  1103         self.LogConsole = wx.TextCtrl(id=ID_BEREMIZLOGCONSOLE, value='',

  1104                   name='LogConsole', parent=self.BottomNoteBook, pos=wx.Point(0, 0),

  1105                   size=wx.Size(0, 0), style=wx.TE_MULTILINE|wx.TE_RICH2)

  1106         self.LogConsole.Bind(wx.EVT_LEFT_DCLICK, self.OnLogConsoleDClick)

  1107         self.BottomNoteBook.AddPage(self.LogConsole, _("Log Console"))

  1108         

  1109         self._init_beremiz_sizers()

  1110 

  1111     def OnCloseFrame(self, event):

  1112         global frame

  1113         

  1114         if self.CheckSaveBeforeClosing(_("Close Application")):

  1115             

  1116             frame.Hide()

  1117             

  1118             self.CTR.ResetAppFrame(lpcberemiz_cmd.Log)

  1119             if self.CTR.OnlineMode == 0:

  1120                 self.CTR._connector = None

  1121             

  1122             self.CTR.KillDebugThread()

  1123             self.KillLocalRuntime()

  1124             

  1125             self.SaveLastState()

  1126             

  1127             lpcberemiz_cmd.Log.write("Closed\n")

  1128             

  1129         event.Veto()

  1130 

  1131     def ShowProperties(self):

  1132         old_values = self.Controler.GetProjectProperties()

  1133         dialog = ProjectDialog(self ,False)

  1134         dialog.SetValues(old_values)

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

  1136             new_values = dialog.GetValues()