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

    49

    50

# Import module for internationalization

    51

import gettext

    52

import __builtin__

    53

    54

if __name__ == '__main__':

    55

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

    56

    57

from Beremiz import *

    58

from plugger import PluginsRoot, PlugTemplate, opjimg, connectors

    59

from plcopen.structures import LOCATIONDATATYPES

    60

from PLCControler import LOCATION_PLUGIN, LOCATION_MODULE, LOCATION_GROUP,\

    61

                         LOCATION_VAR_INPUT, LOCATION_VAR_OUTPUT, LOCATION_VAR_MEMORY

    62

from PLCOpenEditor import IDEFrame, ProjectDialog

    63

    64

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

    65

#                          CANFESTIVAL PLUGIN HACK

    66

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

    67

from plugins.canfestival import canfestival

    68

class LPC_canfestival_config:

    69

    def getCFLAGS(self, *args):

    70

        return ""

    71

    72

    def getLDFLAGS(self, *args):

    73

        return ""

    74

    75

canfestival.local_canfestival_config = LPC_canfestival_config() 

    76

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

    77

#                              LPCModule Class

    78

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

    79

    80

LOCATION_TYPES = {"I": LOCATION_VAR_INPUT,

    81

                  "Q": LOCATION_VAR_OUTPUT,

    82

                  "M": LOCATION_VAR_MEMORY}

    83

    84

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

    85

    86

LOCATION_SIZES = {}

    87

for size, types in LOCATIONDATATYPES.iteritems():

    88

    for type in types:

    89

        LOCATION_SIZES[type] = size

    90

    91

def _GetModuleChildren(module):

    92

    children = []

    93

    for child in module["children"]:

    94

        if child["type"] == LOCATION_GROUP:

    95

            children.extend(child["children"])

    96

        else:

    97

            children.append(child)

    98

    return children

    99

   100

def _GetLastModuleGroup(module):

   101

    group = module

   102

    for child in module["children"]:

   103

        if child["type"] == LOCATION_GROUP:

   104

            group = child

   105

    return group["children"]

   106

   107

def _GetModuleBySomething(module, something, toks):

   108

    for child in _GetModuleChildren(module):

   109

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

   110

            if len(toks) > 1:

   111

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

   112

            return child

   113

    return None

   114

   115

def _GetModuleVariable(module, location, direction):

   116

    for child in _GetModuleChildren(module):

   117

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

   118

            return child

   119

    return None

   120

   121

def _RemoveModuleChild(module, child):

   122

    if child in module["children"]:

   123

        module["children"].remove(child)

   124

    else:

   125

        for group in module["children"]:

   126

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

   127

                group["children"].remove(child)

   128

   129

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

   130

   131

/* LPCBus plugin includes */

   132

#include "app_glue.h"

   133

#ifdef _WINDOWS_H

   134

  #include "iec_types.h"

   135

#else

   136

  #include "iec_std_lib.h"

   137

#endif

   138

   139

%(declare_code)s

   140

   141

/* LPCBus plugin user variables definition */

   142

%(var_decl)s

   143

   144

/* LPCBus plugin functions */

   145

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

   146

{

   147

  return 0;

   148

}

   149

   150

void __cleanup_%(location_str)s(void)

   151

{

   152

}

   153

   154

void __retrieve_%(location_str)s(void)

   155

{

   156

  %(retrieve_code)s

   157

}

   158

   159

void __publish_%(location_str)s(void)

   160

{

   161

  %(publish_code)s

   162

}

   163

"""

   164

   165

class LPCBus(object):

   166

   167

    def __init__(self):

   168

        self.VariableLocationTree = []

   169

        self.ResetUsedLocations()

   170

        self.Icon = None

   171

   172

    def __getitem__(self, key):

   173

        if key == "children":

   174

            return self.VariableLocationTree

   175

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

   176

   177

    def SetIcon(self, icon):

   178

        self.Icon = icon

   179

   180

    def _GetChildBySomething(self, something, toks):

   181

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

   182

   183

    def GetBaseTypes(self):

   184

        return self.GetPlugRoot().GetBaseTypes()

   185

   186

    def GetSizeOfType(self, type):

   187

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

   188

   189

    def _GetVariableLocationTree(self, current_location, infos):

   190

        if infos["type"] == LOCATION_MODULE:

   191

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

   192

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

   193

                    "type": infos["type"],

   194

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

   195

                    "icon": infos["icon"], 

   196

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

   197

        elif infos["type"] == LOCATION_GROUP:

   198

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

   199

                    "type": infos["type"],

   200

                    "location": "", 

   201

                    "icon": infos["icon"], 

   202

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

   203

        else:

   204

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

   205

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

   206

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

   207

                    "type": infos["type"],

   208

                    "size": size,

   209

                    "IEC_type": infos["IEC_type"],

   210

                    "location": location,

   211

                    "description": infos["description"],

   212

                    "children": []}

   213

   214

    def GetVariableLocationTree(self):

   215

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

   216

                "type": LOCATION_PLUGIN,

   217

                "location": self.GetFullIEC_Channel(),

   218

                "icon": self.Icon, 

   219

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

   220

                             for child in self.VariableLocationTree]}

   221

   222

    def PlugTestModified(self):

   223

        return False

   224

   225

    def PlugMakeDir(self):

   226

        pass

   227

   228

    def PlugRequestSave(self):

   229

        return None

   230

   231

    def ResetUsedLocations(self):

   232

        self.UsedLocations = {}

   233

   234

    def _AddUsedLocation(self, parent, location):

   235

        num = location.pop(0)

   236

        if not parent.has_key(num):

   237

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

   238

        if len(location) > 0:

   239

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

   240

        else:

   241

            parent[num]["used"] = True

   242

   243

    def AddUsedLocation(self, location):

   244

        if len(location) > 0:

   245

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

   246

   247

    def _CheckLocationConflicts(self, parent, location):

   248

        num = location.pop(0)

   249

        if not parent.has_key(num):

   250

            return False

   251

        if len(location) > 0:

   252

            if parent[num]["used"]:

   253

                return True

   254

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

   255

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

   256

            return True

   257

        return False

   258

   259

    def CheckLocationConflicts(self, location):

   260

        if len(location) > 0:

   261

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

   262

        return False

   263

   264

    def PlugGenerate_C(self, buildpath, locations):

   265

        """

   266

        Generate C code

   267

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

   268

        @param locations: List of complete variables locations \

   269

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

   270

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

   271

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

   272

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

   273

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

   274

            }, ...]

   275

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

   276

        """

   277

        current_location = self.GetCurrentLocation()

   278

        # define a unique name for the generated C file

   279

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

   280

   281

        code_str = {"location_str": location_str,

   282

                    "var_decl": "",

   283

                    "declare_code": "",

   284

                    "retrieve_code": "",

   285

                    "publish_code": "",

   286

                   }

   287

   288

        # Adding variables

   289

        vars = []

   290

        self.ResetUsedLocations()

   291

        for location in locations:

   292

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

   293

            group = next = self

   294

            i = 0

   295

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

   296

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

   297

                if next is not None:

   298

                    i += 1

   299

                    group = next

   300

            var_loc = loc[i:]

   301

            for variable in _GetModuleChildren(group):

   302

                if variable["location"] == var_loc:

   303

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

   304

#                        raise Exception, "Direction conflict in variable definition"

   305

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

   306

#                        raise Exception, "Type conflict in variable definition"

   307

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

   308

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

   309

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

   310

                        self.AddUsedLocation(location["LOC"])

   311

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

   312

                                 "Type": variable["IEC_type"],

   313

                                 "Declare": variable["declare"],

   314

                                 "Retrieve": variable["retrieve"],

   315

                                 "Publish": variable["publish"],

   316

                                })

   317

                    break

   318

        base_types = self.GetPlugRoot().GetBaseTypes()

   319

        for var in vars:

   320

            prefix = ""

   321

            if var["Type"] in base_types:

   322

                prefix = "IEC_"

   323

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

   324

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

   325

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

   326

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

   327

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

   328

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

   329

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

   330

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

   331

   332

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

   333

        module = open(Gen_Module_path,'w')

   334

        module.write(BUS_TEXT % code_str)

   335

        module.close()

   336

   337

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

   338

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

   339

   340

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

   341

#                              LPCPluginsRoot Class

   342

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

   343

   344

def mycopytree(src, dst):

   345

    """

   346

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

   347

    @param src: source directory

   348

    @param dst: destination directory

   349

    """

   350

    for i in os.listdir(src):

   351

        if not i.startswith('.'):

   352

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

   353

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

   354

            if os.path.isdir(srcpath):

   355

                if os.path.exists(dstpath):

   356

                    shutil.rmtree(dstpath)

   357

                os.makedirs(dstpath)

   358

                mycopytree(srcpath, dstpath)

   359

            elif os.path.isfile(srcpath):

   360

                shutil.copy2(srcpath, dstpath)

   361

   362

[SIMULATION_MODE, TRANSFER_MODE] = range(2)

   363

   364

class LPCPluginsRoot(PluginsRoot):

   365

   366

    PluginMethods = [

   367

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

   368

         "name" : _("Simulate"),

   369

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

   370

         "method" : "_Simulate"},

   371

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

   372

         "name" : _("Run"),

   373

         "shown" : False,

   374

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

   375

         "method" : "_Run"},

   376

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

   377

         "name" : _("Stop"),

   378

         "shown" : False,

   379

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

   380

         "method" : "_Stop"},

   381

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

   382

         "name" : _("Build"),

   383

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

   384

         "method" : "_build"},

   385

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

   386

         "name" : _("Transfer"),

   387

         "shown" : False,

   388

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

   389

         "method" : "_Transfer"},

   390

    ]

   391

   392

    def __init__(self, frame, logger):

   393

        PluginsRoot.__init__(self, frame, logger)

   394

   395

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

   396

   397

        self.OnlineMode = "OFF"

   398

        self.LPCConnector = False

   399

   400

        self.CurrentMode = None

   401

        self.previous_mode = None

   402

   403

        self.SimulationBuildPath = None

   404

   405

        self.AbortTransferTimer = None

   406

   407

    def GetProjectName(self):

   408

        return self.Project.getname()

   409

   410

    def GetDefaultTargetName(self):

   411

        if self.CurrentMode == SIMULATION_MODE:

   412

            return PluginsRoot.GetDefaultTargetName(self)

   413

        else:

   414

            return "LPC"

   415

   416

    def GetTarget(self):

   417

        target = PluginsRoot.GetTarget(self)

   418

        if self.CurrentMode != SIMULATION_MODE:

   419

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

   420

        return target

   421

   422

    def _getBuildPath(self):

   423

        if self.CurrentMode == SIMULATION_MODE:

   424

            if self.SimulationBuildPath is None:

   425

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

   426

            return self.SimulationBuildPath

   427

        else:

   428

            return PluginsRoot._getBuildPath(self)

   429

   430

    def _build(self):

   431

        if self.BuildPath is not None:

   432

            mycopytree(self.OrigBuildPath, self.BuildPath)

   433

        PluginsRoot._build(self)

   434

   435

    def SetProjectName(self, name):

   436

        return self.Project.setname(name)

   437

   438

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

   439

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

   440

            self.OnlineMode = mode.upper()

   441

   442

            if self.OnlineMode != "OFF":

   443

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

   444

                try:

   445

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

   446

                except Exception, msg:

   447

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

   448

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

   449

   450

                # Did connection success ?

   451

                if self.LPCConnector is None:

   452

                    # Oups.

   453

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

   454

   455

            else:

   456

                self.LPCConnector = None

   457

   458

            self.ApplyOnlineMode()

   459

   460

    def ApplyOnlineMode(self):

   461

        if self.CurrentMode != SIMULATION_MODE:

   462

            self.KillDebugThread()

   463

   464

            self._connector = self.LPCConnector

   465

   466

            # Init with actual PLC status and print it

   467

            self.UpdateMethodsFromPLCStatus()

   468

   469

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

   470

   471

                self.CompareLocalAndRemotePLC()

   472

   473

                if self.previous_plcstate is not None:

   474

                    status = _(self.previous_plcstate)

   475

                else:

   476

                    status = ""

   477

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

   478

   479

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

   480

                    # Start the status Timer

   481

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

   482

   483

                if self.previous_plcstate=="Started":

   484

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

   485

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

   486

                        self._connect_debug()

   487

                    else:

   488

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

   489

   490

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

   491

                self.StatusTimer.Stop()

   492

   493

            if self.CurrentMode == TRANSFER_MODE:

   494

   495

                if self.OnlineMode == "BOOTLOADER":

   496

                    self.BeginTransfer()

   497

   498

                elif self.OnlineMode == "APPLICATION":

   499

                    self.CurrentMode = None

   500

                    self.AbortTransferTimer.Stop()

   501

                    self.AbortTransferTimer = None

   502

   503

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

   504

   505

    # Update a PLCOpenEditor Pou variable name

   506

    def UpdateProjectVariableName(self, old_name, new_name):

   507

        self.Project.updateElementName(old_name, new_name)

   508

        self.BufferProject()

   509

   510

    def RemoveProjectVariableByAddress(self, address):

   511

        self.Project.removeVariableByAddress(address)

   512

        self.BufferProject()

   513