1

#!/usr/bin/env python

     2

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

     3

import shutil

     4

     5

__version__ = "$Revision$"

     6

     7

import os, sys, getopt, wx, tempfile

     8

from types import TupleType, StringType, UnicodeType

     9

    10

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

    11

    12

def Bpath(*args):

    13

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

    14

    15

if __name__ == '__main__':

    16

    def usage():

    17

        print "\nUsage of LPCBeremiz.py :"

    18

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

    19

    20

    try:

    21

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

    22

    except getopt.GetoptError:

    23

        # print help information and exit:

    24

        usage()

    25

        sys.exit(2)

    26

    27

    for o, a in opts:

    28

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

    29

            usage()

    30

            sys.exit()

    31

    32

    if len(args) > 2:

    33

        usage()

    34

        sys.exit()

    35

    elif len(args) == 1:

    36

        projectOpen = args[0]

    37

        buildpath = None

    38

    elif len(args) == 2:

    39

        projectOpen = args[0]

    40

        buildpath = args[1]

    41

    else:

    42

        projectOpen = None

    43

        buildpath = None

    44

    45

class PseudoLocale:

    46

    LocaleDirs = []

    47

    Domains = []

    48

    49

    def AddCatalogLookupPathPrefix(self, localedir):

    50

        self.LocaleDirs.append(localedir)

    51

    52

    def AddCatalog(self, domain):

    53

        self.Domains.append(domain)

    54

    55

# Import module for internationalization

    56

import gettext

    57

import __builtin__

    58

    59

# Define locale for wx

    60

__builtin__.__dict__['loc'] = PseudoLocale()

    61

    62

if __name__ == '__main__':

    63

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

    64

    65

from Beremiz import *

    66

from plugger import PluginsRoot, PlugTemplate, opjimg, connectors

    67

from plcopen.structures import LOCATIONDATATYPES

    68

from PLCControler import LOCATION_PLUGIN, LOCATION_MODULE, LOCATION_GROUP,\

    69

                         LOCATION_VAR_INPUT, LOCATION_VAR_OUTPUT, LOCATION_VAR_MEMORY

    70

from PLCOpenEditor import IDEFrame, ProjectDialog

    71

    72

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

    73

#                          CANFESTIVAL PLUGIN HACK

    74

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

    75

from plugins.canfestival import canfestival

    76

class LPC_canfestival_config:

    77

    def getCFLAGS(self, *args):

    78

        return ""

    79

    80

    def getLDFLAGS(self, *args):

    81

        return ""

    82

    83

canfestival.local_canfestival_config = LPC_canfestival_config() 

    84

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

    85

#                              LPCModule Class

    86

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

    87

    88

LOCATION_TYPES = {"I": LOCATION_VAR_INPUT,

    89

                  "Q": LOCATION_VAR_OUTPUT,

    90

                  "M": LOCATION_VAR_MEMORY}

    91

    92

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

    93

    94

LOCATION_SIZES = {}

    95

for size, types in LOCATIONDATATYPES.iteritems():

    96

    for type in types:

    97

        LOCATION_SIZES[type] = size

    98

    99

def _GetModuleChildren(module):

   100

    children = []

   101

    for child in module["children"]:

   102

        if child["type"] == LOCATION_GROUP:

   103

            children.extend(child["children"])

   104

        else:

   105

            children.append(child)

   106

    return children

   107

   108

def _GetLastModuleGroup(module):

   109

    group = module

   110

    for child in module["children"]:

   111

        if child["type"] == LOCATION_GROUP:

   112

            group = child

   113

    return group["children"]

   114

   115

def _GetModuleBySomething(module, something, toks):

   116

    for child in _GetModuleChildren(module):

   117

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

   118

            if len(toks) > 1:

   119

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

   120

            return child

   121

    return None

   122

   123

def _GetModuleVariable(module, location, direction):

   124

    for child in _GetModuleChildren(module):

   125

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

   126

            return child

   127

    return None

   128

   129

def _RemoveModuleChild(module, child):

   130

    if child in module["children"]:

   131

        module["children"].remove(child)

   132

    else:

   133

        for group in module["children"]:

   134

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

   135

                group["children"].remove(child)

   136

   137

BUS_TEXT = """/* Code generated by LPCBus plugin */

   138

   139

/* LPCBus plugin includes */

   140

#include "app_glue.h"

   141

#ifdef _WINDOWS_H

   142

  #include "iec_types.h"

   143

#else

   144

  #include "iec_std_lib.h"

   145

#endif

   146

   147

%(declare_code)s

   148

   149

/* LPCBus plugin user variables definition */

   150

%(var_decl)s

   151

   152

/* LPCBus plugin functions */

   153

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

   154

{

   155

  return 0;

   156

}

   157

   158

void __cleanup_%(location_str)s(void)

   159

{

   160

}

   161

   162

void __retrieve_%(location_str)s(void)

   163

{

   164

  %(retrieve_code)s

   165

}

   166

   167

void __publish_%(location_str)s(void)

   168

{

   169

  %(publish_code)s

   170

}

   171

"""

   172

   173

class LPCBus(object):

   174

   175

    def __init__(self):

   176

        self.VariableLocationTree = []

   177

        self.ResetUsedLocations()

   178

        self.Icon = None

   179

   180

    def __getitem__(self, key):

   181

        if key == "children":

   182

            return self.VariableLocationTree

   183

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

   184

   185

    def SetIcon(self, icon):

   186

        self.Icon = icon

   187

   188

    def _GetChildBySomething(self, something, toks):

   189

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

   190

   191

    def GetBaseTypes(self):

   192

        return self.GetPlugRoot().GetBaseTypes()

   193

   194

    def GetSizeOfType(self, type):

   195

        return LOCATION_SIZES[self.GetPlugRoot().GetBaseType(type)]

   196

   197

    def _GetVariableLocationTree(self, current_location, infos):

   198

        if infos["type"] == LOCATION_MODULE:

   199

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

   200

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

   201

                    "type": infos["type"],

   202

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

   203

                    "icon": infos["icon"], 

   204

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

   205

        elif infos["type"] == LOCATION_GROUP:

   206

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

   207

                    "type": infos["type"],

   208

                    "location": "", 

   209

                    "icon": infos["icon"], 

   210

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

   211

        else:

   212

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

   213

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

   214

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

   215

                    "type": infos["type"],

   216

                    "size": size,

   217

                    "IEC_type": infos["IEC_type"],

   218

                    "location": location,

   219

                    "description": infos["description"],

   220

                    "children": []}

   221

   222

    def GetVariableLocationTree(self):

   223

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

   224

                "type": LOCATION_PLUGIN,

   225

                "location": self.GetFullIEC_Channel(),

   226

                "icon": self.Icon, 

   227

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

   228

                             for child in self.VariableLocationTree]}

   229

   230

    def PlugTestModified(self):

   231

        return False

   232

   233

    def PlugMakeDir(self):

   234

        pass

   235

   236

    def PlugRequestSave(self):

   237

        return None

   238

   239

    def ResetUsedLocations(self):

   240

        self.UsedLocations = {}

   241

   242

    def _AddUsedLocation(self, parent, location):

   243

        num = location.pop(0)

   244

        if not parent.has_key(num):

   245

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

   246

        if len(location) > 0:

   247

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

   248

        else:

   249

            parent[num]["used"] = True

   250

   251

    def AddUsedLocation(self, location):

   252

        if len(location) > 0:

   253

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

   254

   255

    def _CheckLocationConflicts(self, parent, location):

   256

        num = location.pop(0)

   257

        if not parent.has_key(num):

   258

            return False

   259

        if len(location) > 0:

   260

            if parent[num]["used"]:

   261

                return True

   262

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

   263

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

   264

            return True

   265

        return False

   266

   267

    def CheckLocationConflicts(self, location):

   268

        if len(location) > 0:

   269

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

   270

        return False

   271

   272

    def PlugGenerate_C(self, buildpath, locations):

   273

        """

   274

        Generate C code

   275

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

   276

        @param locations: List of complete variables locations \

   277

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

   278

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

   279

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

   280

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

   281

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

   282

            }, ...]

   283

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

   284

        """

   285

        current_location = self.GetCurrentLocation()

   286

        # define a unique name for the generated C file

   287

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

   288

   289

        code_str = {"location_str": location_str,

   290

                    "var_decl": "",

   291

                    "declare_code": "",

   292

                    "retrieve_code": "",

   293

                    "publish_code": "",

   294

                   }

   295

   296

        # Adding variables

   297

        vars = []

   298

        self.ResetUsedLocations()

   299

        for location in locations:

   300

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

   301

            group = next = self

   302

            i = 0

   303

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

   304

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

   305

                if next is not None:

   306

                    i += 1

   307

                    group = next

   308

            var_loc = loc[i:]

   309

            for variable in group["children"]:

   310

                if variable["location"] == var_loc:

   311

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

   312

                        raise Exception, "Direction conflict in variable definition"

   313

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

   314

                        raise Exception, "Type conflict in variable definition"

   315

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

   316

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

   317

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

   318

                        self.AddUsedLocation(location["LOC"])

   319

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

   320

                                 "Type": variable["IEC_type"],

   321

                                 "Declare": variable["declare"],

   322

                                 "Retrieve": variable["retrieve"],

   323

                                 "Publish": variable["publish"],

   324

                                })

   325

                    break

   326

        base_types = self.GetPlugRoot().GetBaseTypes()

   327

        for var in vars:

   328

            prefix = ""

   329

            if var["Type"] in base_types:

   330

                prefix = "IEC_"

   331

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

   332

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

   333

            if var["Declare"] != "":

   334

                code_str["declare_code"] += var["Declare"] + "\n"

   335

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

   336

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

   337

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

   338

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

   339

   340

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

   341

        module = open(Gen_Module_path,'w')

   342

        module.write(BUS_TEXT % code_str)

   343

        module.close()

   344

   345

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

   346

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

   347

   348

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

   349

#                              LPCPluginsRoot Class

   350

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

   351

   352

def mycopytree(src, dst):

   353

    """

   354

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

   355

    @param src: source directory

   356

    @param dst: destination directory

   357

    """

   358

    for i in os.listdir(src):

   359

        if not i.startswith('.'):

   360

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

   361

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

   362

            if os.path.isdir(srcpath):

   363

                if os.path.exists(dstpath):

   364

                    shutil.rmtree(dstpath)

   365

                os.makedirs(dstpath)

   366

                mycopytree(srcpath, dstpath)

   367

            elif os.path.isfile(srcpath):

   368

                shutil.copy2(srcpath, dstpath)

   369

   370

class LPCPluginsRoot(PluginsRoot):

   371

   372

    PluginMethods = [

   373

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

   374

         "name" : _("Simulate"),

   375

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

   376

         "method" : "_Simulate"},

   377

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

   378

         "name" : _("Run"),

   379

         "shown" : False,

   380

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

   381

         "method" : "_Run"},

   382

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

   383

         "name" : _("Stop"),

   384

         "shown" : False,

   385

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

   386

         "method" : "_Stop"},

   387

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

   388

         "name" : _("Build"),

   389

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

   390

         "method" : "_build"},

   391

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

   392

         "name" : _("Transfer"),

   393

         "shown" : False,

   394

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

   395

         "method" : "_Transfer"},

   396

    ]

   397

   398

    def __init__(self, frame, logger):

   399

        PluginsRoot.__init__(self, frame, logger)

   400

   401

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

   402

   403

        self.OnlineMode = 0

   404

        self.OnlinePath = None

   405

   406

        self.BuildSimulation = False

   407

        self.SimulationBuildPath = None

   408

   409

        self.previous_simulating = False

   410

   411

    def GetProjectName(self):

   412

        return self.Project.getname()

   413

   414

    def GetDefaultTargetName(self):

   415

        if self.BuildSimulation:

   416

            return PluginsRoot.GetDefaultTargetName(self)

   417

        else:

   418

            return "LPC"

   419

   420

    def GetTarget(self):

   421

        target = PluginsRoot.GetTarget(self)

   422

        if not self.BuildSimulation:

   423

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

   424

        return target

   425

   426

    def _getBuildPath(self):

   427

        if self.BuildSimulation:

   428

            if self.SimulationBuildPath is None:

   429

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

   430

            return self.SimulationBuildPath

   431

        else:

   432

            return PluginsRoot._getBuildPath(self)

   433

   434

    def _build(self):

   435

        if self.BuildPath is not None:

   436

            mycopytree(self.OrigBuildPath, self.BuildPath)

   437

        PluginsRoot._build(self)

   438

   439

    def SetProjectName(self, name):

   440

        return self.Project.setname(name)

   441

   442

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

   443

        if self.OnlineMode != mode:

   444

            self.OnlineMode = mode

   445

            self.KillDebugThread()

   446

   447

            if self.OnLineMode != 0:

   448

                if self._connector is None:

   449

                    uri = "LPC://%s" % path

   450

                    try:

   451

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

   452

                    except Exception, msg:

   453

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

   454

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

   455

   456

                    # Did connection success ?

   457

                    if self._connector is None:

   458

                        # Oups.

   459

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

   460

   461

                if self._connector is not None:

   462

   463

                    if self.OnLineMode == 1:

   464

                        self.CompareLocalAndRemotePLC()

   465

   466

                        # Init with actual PLC status and print it

   467

                        self.UpdateMethodsFromPLCStatus()

   468

                        if self.previous_plcstate is not None:

   469

                            status = _(self.previous_plcstate)

   470

                        else:

   471

                            status = ""

   472

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

   473

   474

                        # Start the status Timer

   475

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

   476

   477

                        if self.previous_plcstate=="Started":

   478

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

   479

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

   480

                                self._connect_debug()

   481

                            else:

   482

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

   483

   484

            else:

   485

                self._connector = None

   486

                self.StatusTimer.Stop()

   487

   488

            self.OnlinePath = path

   489

            self.UpdateMethodsFromPLCStatus()

   490

   491

    # Update a PLCOpenEditor Pou variable name

   492

    def UpdateProjectVariableName(self, old_name, new_name):

   493

        self.Project.updateElementName(old_name, new_name)

   494

        self.BufferProject()

   495

   496

    def RemoveProjectVariableByAddress(self, address):

   497

        self.Project.removeVariableByAddress(address)

   498

        self.BufferProject()

   499

   500

    def RemoveProjectVariableByFilter(self, leading):

   501

        self.Project.removeVariableByFilter(leading)

   502

        self.BufferProject()

   503

   504

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

   505

        """

   506

        Load a project contained in a folder

   507

        @param ProjectPath: path of the project folder

   508

        """

   509

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

   510

            ProjectPath = os.path.dirname(ProjectPath)

   511

   512

        # Verify that project contains a PLCOpen program

   513

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

   514

        if os.path.isfile(plc_file):

   515

            # Load PLCOpen file