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 plugger import PluginsRoot, PlugTemplate, opjimg, connectors

    63

from plcopen.structures import LOCATIONDATATYPES

    64

from PLCControler import LOCATION_PLUGIN, LOCATION_MODULE, LOCATION_GROUP,\

    65

                         LOCATION_VAR_INPUT, LOCATION_VAR_OUTPUT, LOCATION_VAR_MEMORY

    66

from PLCOpenEditor import IDEFrame, ProjectDialog

    67

    68

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

    69

#                          CANFESTIVAL PLUGIN HACK

    70

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

    71

# from plugins.canfestival import canfestival

    72

# class LPC_canfestival_config:

    73

#     def getCFLAGS(self, *args):

    74

#         return ""

    75

# 

    76

#     def getLDFLAGS(self, *args):

    77

#         return ""

    78

#         

    79

# canfestival.local_canfestival_config = LPC_canfestival_config() 

    80

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

    81

#                              LPCModule Class

    82

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

    83

    84

LOCATION_TYPES = {"I": LOCATION_VAR_INPUT,

    85

                  "Q": LOCATION_VAR_OUTPUT,

    86

                  "M": LOCATION_VAR_MEMORY}

    87

    88

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

    89

    90

LOCATION_SIZES = {}

    91

for size, types in LOCATIONDATATYPES.iteritems():

    92

    for type in types:

    93

        LOCATION_SIZES[type] = size

    94

    95

def _GetModuleChildren(module):

    96

    children = []

    97

    for child in module["children"]:

    98

        if child["type"] == LOCATION_GROUP:

    99

            children.extend(child["children"])

   100

        else:

   101

            children.append(child)

   102

    return children

   103

   104

def _GetVariables(module):

   105

    variables = []

   106

    for child in module["children"]:

   107

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

   108

            variables.extend(_GetVariables(child))

   109

        else:

   110

            variables.append(child)

   111

    return variables

   112

   113

def _GetLastModuleGroup(module):

   114

    group = module

   115

    for child in module["children"]:

   116

        if child["type"] == LOCATION_GROUP:

   117

            group = child

   118

    return group["children"]

   119

   120

def _GetModuleBySomething(module, something, toks):

   121

    for child in _GetModuleChildren(module):

   122

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

   123

            if len(toks) > 1:

   124

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

   125

            return child

   126

    return None

   127

   128

def _GetModuleVariable(module, location, direction):

   129

    for child in _GetModuleChildren(module):

   130

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

   131

            return child

   132

    return None

   133

   134

def _RemoveModuleChild(module, child):

   135

    if child in module["children"]:

   136

        module["children"].remove(child)

   137

    else:

   138

        for group in module["children"]:

   139

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

   140

                group["children"].remove(child)

   141

   142

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

   143

   144

/* LPCBus plugin includes */

   145

#include "app_glue.h"

   146

#ifdef _WINDOWS_H

   147

  #include "iec_types.h"

   148

#else

   149

  #include "iec_std_lib.h"

   150

#endif

   151

   152

%(declare_code)s

   153

   154

/* LPCBus plugin user variables definition */

   155

%(var_decl)s

   156

   157

/* LPCBus plugin functions */

   158

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

   159

{

   160

%(init_code)s

   161

  return 0;

   162

}

   163

   164

void __cleanup_%(location_str)s(void)

   165

{

   166

}

   167

   168

void __retrieve_%(location_str)s(void)

   169

{

   170

%(retrieve_code)s

   171

}

   172

   173

void __publish_%(location_str)s(void)

   174

{

   175

%(publish_code)s

   176

}

   177

"""

   178

   179

class LPCBus(object):

   180

   181

    def __init__(self):

   182

        self.VariableLocationTree = []

   183

        self.ResetUsedLocations()

   184

        self.Icon = None

   185

   186

    def __getitem__(self, key):

   187

        if key == "children":

   188

            return self.VariableLocationTree

   189

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

   190

   191

    def SetIcon(self, icon):

   192

        self.Icon = icon

   193

   194

    def _GetChildBySomething(self, something, toks):

   195

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

   196

   197

    def GetBaseTypes(self):

   198

        return self.GetPlugRoot().GetBaseTypes()

   199

   200

    def GetSizeOfType(self, type):

   201

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

   202

   203

    def _GetVariableLocationTree(self, current_location, infos):

   204

        if infos["type"] == LOCATION_MODULE:

   205

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

   206

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

   207

                    "type": infos["type"],

   208

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

   209

                    "icon": infos["icon"], 

   210

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

   211

        elif infos["type"] == LOCATION_GROUP:

   212

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

   213

                    "type": infos["type"],

   214

                    "location": "", 

   215

                    "icon": infos["icon"], 

   216

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

   217

        else:

   218

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

   219

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

   220

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

   221

                    "type": infos["type"],

   222

                    "size": size,

   223

                    "IEC_type": infos["IEC_type"],

   224

                    "var_name": infos["name"],

   225

                    "location": location,

   226

                    "description": infos["description"],

   227

                    "children": []}

   228

   229

    def GetVariableLocationTree(self):

   230

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

   231

                "type": LOCATION_PLUGIN,

   232

                "location": self.GetFullIEC_Channel(),

   233

                "icon": self.Icon, 

   234

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

   235

                             for child in self.VariableLocationTree]}

   236

   237

    def PlugTestModified(self):

   238

        return False

   239

   240

    def PlugMakeDir(self):

   241

        pass

   242

   243

    def PlugRequestSave(self):

   244

        return None

   245

   246

    def ResetUsedLocations(self):

   247

        self.UsedLocations = {}

   248

   249

    def _AddUsedLocation(self, parent, location):

   250

        num = location.pop(0)

   251

        if not parent.has_key(num):

   252

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

   253

        if len(location) > 0:

   254

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

   255

        else:

   256

            parent[num]["used"] = True

   257

   258

    def AddUsedLocation(self, location):

   259

        if len(location) > 0:

   260

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

   261

   262

    def _CheckLocationConflicts(self, parent, location):

   263

        num = location.pop(0)

   264

        if not parent.has_key(num):

   265

            return False

   266

        if len(location) > 0:

   267

            if parent[num]["used"]:

   268

                return True

   269

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

   270

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

   271

            return True

   272

        return False

   273

   274

    def CheckLocationConflicts(self, location):

   275

        if len(location) > 0:

   276

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

   277

        return False

   278

   279

    def PlugGenerate_C(self, buildpath, locations):

   280

        """

   281

        Generate C code

   282

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

   283

        @param locations: List of complete variables locations \

   284

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

   285

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

   286

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

   287

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

   288

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

   289

            }, ...]

   290

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

   291

        """

   292

        current_location = self.GetCurrentLocation()

   293

        # define a unique name for the generated C file

   294

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

   295

   296

        code_str = {"location_str": location_str,

   297

                    "var_decl": "",

   298

                    "declare_code": "",

   299

                    "init_code": "",

   300

                    "retrieve_code": "",

   301

                    "publish_code": "",

   302

                   }

   303

   304

        for module in _GetModuleChildren(self):

   305

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

   306

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

   307

   308

        # Adding variables

   309

        vars = []

   310

        self.ResetUsedLocations()

   311

        for location in locations:

   312

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

   313

            group = next = self

   314

            i = 0

   315

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

   316

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

   317

                if next is not None:

   318

                    i += 1

   319

                    group = next

   320

            var_loc = loc[i:]

   321

            for variable in _GetModuleChildren(group):

   322

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

   323

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

   324

#                        raise Exception, "Direction conflict in variable definition"

   325

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

   326

#                        raise Exception, "Type conflict in variable definition"

   327

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

   328

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

   329

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

   330

                        self.AddUsedLocation(location["LOC"])

   331

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

   332

                                 "Type": variable["IEC_type"],

   333

                                 "Retrieve": variable["retrieve"],

   334

                                 "Publish": variable["publish"],

   335

                                })

   336

                    break

   337

        base_types = self.GetPlugRoot().GetBaseTypes()

   338

        for var in vars:

   339

            prefix = ""

   340

            if var["Type"] in base_types:

   341

                prefix = "IEC_"

   342

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

   343

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

   344

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

   345

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

   346

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

   347

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

   348

   349

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

   350

        module = open(Gen_Module_path,'w')

   351

        module.write(BUS_TEXT % code_str)

   352

        module.close()

   353

   354

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

   355

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

   356

   357

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

   358

#                              LPCPluginsRoot Class

   359

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

   360

   361

def mycopytree(src, dst):

   362

    """

   363

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

   364

    @param src: source directory

   365

    @param dst: destination directory

   366

    """

   367

    for i in os.listdir(src):

   368

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

   369

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

   370

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

   371

            if os.path.isdir(srcpath):

   372

                if os.path.exists(dstpath):

   373

                    shutil.rmtree(dstpath)

   374

                os.makedirs(dstpath)

   375

                mycopytree(srcpath, dstpath)

   376

            elif os.path.isfile(srcpath):

   377

                shutil.copy2(srcpath, dstpath)

   378

   379

[SIMULATION_MODE, TRANSFER_MODE] = range(2)

   380

   381

class LPCPluginsRoot(PluginsRoot):

   382

   383

    PluginMethods = [

   384

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

   385

         "name" : _("Simulate"),

   386

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

   387

         "method" : "_Simulate"},

   388

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

   389

         "name" : _("Run"),

   390

         "shown" : False,

   391

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

   392

         "method" : "_Run"},

   393

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

   394

         "name" : _("Stop"),

   395

         "shown" : False,

   396

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

   397

         "method" : "_Stop"},

   398

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

   399

         "name" : _("Build"),

   400

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

   401

         "method" : "_Build"},

   402

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

   403

         "name" : _("Transfer"),

   404

         "shown" : False,

   405

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

   406

         "method" : "_Transfer"},

   407

    ]

   408

   409

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

   410

        self.OrigBuildPath = buildpath

   411

   412

        PluginsRoot.__init__(self, frame, logger)

   413

   414

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

   415

        self.PlugType = "LPC"

   416

   417

        self.OnlineMode = "OFF"

   418

        self.LPCConnector = None

   419

   420

        self.CurrentMode = None

   421

        self.previous_mode = None

   422

   423

        self.SimulationBuildPath = None

   424

   425

        self.AbortTransferTimer = None

   426

   427

    def PluginLibraryFilePath(self):

   428

        if self.OrigBuildPath is not None:

   429

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

   430

        else:

   431

            return PluginsRoot.PluginLibraryFilePath(self)

   432

   433

    def GetProjectName(self):

   434

        return self.Project.getname()

   435

   436

    def GetDefaultTargetName(self):

   437

        if self.CurrentMode == SIMULATION_MODE:

   438

            return PluginsRoot.GetDefaultTargetName(self)

   439

        else:

   440

            return "LPC"

   441

   442

    def GetTarget(self):

   443

        target = PluginsRoot.GetTarget(self)

   444

        if self.CurrentMode != SIMULATION_MODE:

   445

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

   446

        return target

   447

   448

    def _getBuildPath(self):

   449

        if self.CurrentMode == SIMULATION_MODE:

   450

            if self.SimulationBuildPath is None:

   451

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

   452

            return self.SimulationBuildPath

   453

        else:

   454

            return PluginsRoot._getBuildPath(self)

   455

   456

    def _Build(self):

   457

        save = self.ProjectTestModified()

   458

        if save:

   459

            self.SaveProject()

   460

            self.AppFrame._Refresh(TITLE, FILEMENU)

   461

        if self.BuildPath is not None:

   462

            mycopytree(self.OrigBuildPath, self.BuildPath)

   463

        PluginsRoot._Build(self)

   464

        if save:

   465

            wx.CallAfter(self.AppFrame.RefreshAll)

   466

   467

    def SetProjectName(self, name):

   468

        return self.Project.setname(name)

   469

   470

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

   471

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

   472

            self.OnlineMode = mode.upper()

   473

   474

            if self.OnlineMode != "OFF":

   475

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

   476

                try:

   477

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

   478

                except Exception, msg:

   479

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

   480

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

   481

   482

                # Did connection success ?

   483

                if self.LPCConnector is None:

   484

                    # Oups.

   485

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

   486

   487

            else:

   488

                self.LPCConnector = None

   489

   490

            self.ApplyOnlineMode()

   491

   492

    def ApplyOnlineMode(self):

   493

        if self.CurrentMode != SIMULATION_MODE:

   494

            self.KillDebugThread()

   495

   496

            self._connector = self.LPCConnector

   497

   498

            # Init with actual PLC status and print it

   499

            self.UpdateMethodsFromPLCStatus()

   500

   501

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

   502

   503

                self.CompareLocalAndRemotePLC()

   504

   505

                if self.previous_plcstate is not None:

   506

                    status = _(self.previous_plcstate)

   507

                else:

   508

                    status = ""

   509

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