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 LPCManager.py :"

    20

        print "\n   %s Projectpath Buildpath port [arch]\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 or len(args) > 4:

    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

        if len(args) > 3:

    46

            arch = args[3]

    47

        else:

    48

            arch = "MC8"

    49

    50

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

    51

        __builtin__.__dict__["BMZ_DBG"] = True

    52

    else :

    53

        __builtin__.__dict__["BMZ_DBG"] = False

    54

    55

app = wx.PySimpleApp(redirect=BMZ_DBG)

    56

app.SetAppName('beremiz')

    57

wx.InitAllImageHandlers()

    58

    59

_base_folder = os.path.split(sys.path[0])[0]

    60

sys.path.append(os.path.join(_base_folder, "beremiz"))

    61

    62

from util.TranslationCatalogs import AddCatalog

    63

AddCatalog(os.path.join(CWD, "locale"))

    64

    65

if __name__ == '__main__':

    66

    # Import module for internationalization

    67

    import gettext

    68

    69

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

    70

    __builtin__.__dict__['_'] = lambda x: x

    71

    72

_base_path = os.path.split(__file__)[0]

    73

import features

    74

from POULibrary import POULibrary

    75

    76

class PLCLibrary(POULibrary):

    77

    def GetLibraryPath(self):

    78

        return os.path.join(_base_path, "pous.xml")

    79

    83

    84

    85

import connectors

    86

from LPCconnector import LPC_connector_factory

    87

connectors.connectors["LPC"]=lambda:LPC_connector_factory

    88

    89

import targets

    90

from LPCtarget import LPC_target 

    91

targets.targets["LPC"] = {"xsd": os.path.join(_base_path, "LPCtarget", "XSD"),

    92

                          "class": lambda: LPC_target,

    93

                          "code": os.path.join(_base_path,"LPCtarget","plc_LPC_main.c")} 

    94

targets.toolchains["makefile"] = os.path.join(_base_path, "LPCtarget", "XSD_toolchain_makefile")

    95

    96

from Beremiz import *

    97

from ProjectController import ProjectController

    98

from ConfigTreeNode import ConfigTreeNode

    99

from editors.ProjectNodeEditor import ProjectNodeEditor

   100

   101

from plcopen.structures import LOCATIONDATATYPES

   102

from PLCControler import PLCControler, LOCATION_CONFNODE, LOCATION_MODULE, LOCATION_GROUP,\

   103

                         LOCATION_VAR_INPUT, LOCATION_VAR_OUTPUT, LOCATION_VAR_MEMORY

   104

from IDEFrame import IDEFrame

   105

from dialogs import ProjectDialog

   106

from controls import TextCtrlAutoComplete

   107

   108

havecanfestival = False

   109

try:

   110

    from canfestival import RootClass as CanOpenRootClass

   111

    from canfestival.canfestival import _SlaveCTN, _NodeListCTN, NodeManager

   112

    from canfestival.NetworkEditor import NetworkEditor

   113

    from canfestival.SlaveEditor import SlaveEditor

   114

    havecanfestival = True

   115

except:

   116

    havecanfestival = False

   117

   118

SCROLLBAR_UNIT = 10

   119

WINDOW_COLOUR = wx.Colour(240,240,240)

   120

TITLE_COLOUR = wx.Colour(200,200,220)

   121

CHANGED_TITLE_COLOUR = wx.Colour(220,200,220)

   122

CHANGED_WINDOW_COLOUR = wx.Colour(255,240,240)

   123

   124

if wx.Platform == '__WXMSW__':

   125

    faces = { 'times': 'Times New Roman',

   126

              'mono' : 'Courier New',

   127

              'helv' : 'Arial',

   128

              'other': 'Comic Sans MS',

   129

              'size' : 16,

   130

             }

   131

else:

   132

    faces = { 'times': 'Times',

   133

              'mono' : 'Courier',

   134

              'helv' : 'Helvetica',

   135

              'other': 'new century schoolbook',

   136

              'size' : 18,

   137

             }

   138

   139

# Some helpers to tweak GenBitmapTextButtons

   140

# TODO: declare customized classes instead.

   141

gen_mini_GetBackgroundBrush = lambda obj:lambda dc: wx.Brush(obj.GetParent().GetBackgroundColour(), wx.SOLID)

   142

gen_textbutton_GetLabelSize = lambda obj:lambda:(wx.lib.buttons.GenButton._GetLabelSize(obj)[:-1] + (False,))

   143

   144

def make_genbitmaptogglebutton_flat(button):

   145

    button.GetBackgroundBrush = gen_mini_GetBackgroundBrush(button)

   146

    button.labelDelta = 0

   147

    button.SetBezelWidth(0)

   148

    button.SetUseFocusIndicator(False)

   149

   150

# Patch wx.lib.imageutils so that gray is supported on alpha images

   151

import wx.lib.imageutils

   152

from wx.lib.imageutils import grayOut as old_grayOut

   153

def grayOut(anImage):

   154

    if anImage.HasAlpha():

   155

        AlphaData = anImage.GetAlphaData()

   156

    else :

   157

        AlphaData = None

   158

   159

    old_grayOut(anImage)

   160

   161

    if AlphaData is not None:

   162

        anImage.SetAlphaData(AlphaData)

   163

   164

wx.lib.imageutils.grayOut = grayOut

   165

   166

class GenBitmapTextButton(wx.lib.buttons.GenBitmapTextButton):

   167

    def _GetLabelSize(self):

   168

        """ used internally """

   169

        w, h = self.GetTextExtent(self.GetLabel())

   170

        if not self.bmpLabel:

   171

            return w, h, False       # if there isn't a bitmap use the size of the text

   172

   173

        w_bmp = self.bmpLabel.GetWidth()+2

   174

        h_bmp = self.bmpLabel.GetHeight()+2

   175

        height = h + h_bmp

   176

        if w_bmp > w:

   177

            width = w_bmp

   178

        else:

   179

            width = w

   180

        return width, height, False

   181

   182

    def DrawLabel(self, dc, width, height, dw=0, dy=0):

   183

        bmp = self.bmpLabel

   184

        if bmp != None:     # if the bitmap is used

   185

            if self.bmpDisabled and not self.IsEnabled():

   186

                bmp = self.bmpDisabled

   187

            if self.bmpFocus and self.hasFocus:

   188

                bmp = self.bmpFocus

   189

            if self.bmpSelected and not self.up:

   190

                bmp = self.bmpSelected

   191

            bw,bh = bmp.GetWidth(), bmp.GetHeight()

   192

            if not self.up:

   193

                dw = dy = self.labelDelta

   194

            hasMask = bmp.GetMask() != None

   195

        else:

   196

            bw = bh = 0     # no bitmap -> size is zero

   197

   198

        dc.SetFont(self.GetFont())

   199

        if self.IsEnabled():

   200

            dc.SetTextForeground(self.GetForegroundColour())

   201

        else:

   202

            dc.SetTextForeground(wx.SystemSettings.GetColour(wx.SYS_COLOUR_GRAYTEXT))

   203

   204

        label = self.GetLabel()

   205

        tw, th = dc.GetTextExtent(label)        # size of text

   206

        if not self.up:

   207

            dw = dy = self.labelDelta

   208

   209

        pos_x = (width-bw)/2+dw      # adjust for bitmap and text to centre

   210

        pos_y = (height-bh-th)/2+dy

   211

        if bmp !=None:

   212

            dc.DrawBitmap(bmp, pos_x, pos_y, hasMask) # draw bitmap if available

   213

            pos_x = (width-tw)/2+dw      # adjust for bitmap and text to centre

   214

            pos_y += bh + 2

   215

   216

        dc.DrawText(label, pos_x, pos_y)      # draw the text

   217

   218

   219

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

   220

#                          CANFESTIVAL CONFNODE HACK

   221

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

   222

# from canfestival import canfestival

   223

# class LPC_canfestival_config:

   224

#     def getCFLAGS(self, *args):

   225

#         return ""

   226

# 

   227

#     def getLDFLAGS(self, *args):

   228

#         return ""

   229

#         

   230

# canfestival.local_canfestival_config = LPC_canfestival_config() 

   231

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

   232

#                              LPCModule Class

   233

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

   234

   235

LOCATION_TYPES = {"I": LOCATION_VAR_INPUT,

   236

                  "Q": LOCATION_VAR_OUTPUT,

   237

                  "M": LOCATION_VAR_MEMORY}

   238

   239

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

   240

   241

LOCATION_SIZES = {}

   242

for size, types in LOCATIONDATATYPES.iteritems():

   243

    for type in types:

   244

        LOCATION_SIZES[type] = size

   245

   246

def _GetModuleChildren(module):

   247

    children = []

   248

    for child in module["children"]:

   249

        if child["type"] == LOCATION_GROUP:

   250

            children.extend(child["children"])

   251

        else:

   252

            children.append(child)

   253

    return children

   254

   255

def _GetVariables(module):

   256

    variables = []

   257

    for child in module["children"]:

   258

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

   259

            variables.extend(_GetVariables(child))

   260

        else:

   261

            variables.append(child)

   262

    return variables

   263

   264

def _GetLastModuleGroup(module):

   265

    group = module

   266

    for child in module["children"]:

   267

        if child["type"] == LOCATION_GROUP:

   268

            group = child

   269

    return group["children"]

   270

   271

def _GetModuleBySomething(module, something, toks):

   272

    for child in _GetModuleChildren(module):

   273

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

   274

            if len(toks) > 1:

   275

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

   276

            return child

   277

    return None

   278

   279

def _GetModuleVariable(module, location, direction):

   280

    for child in _GetModuleChildren(module):

   281

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

   282

            return child

   283

    return None

   284

   285

def _RemoveModuleChild(module, child):

   286

    if child in module["children"]:

   287

        module["children"].remove(child)

   288

    else:

   289

        for group in module["children"]:

   290

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

   291

                group["children"].remove(child)

   292

   293

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

   294

   295

/* LPCBus confnode includes */

   296

#include "app_glue.h"

   297

#ifdef _WINDOWS_H

   298

  #include "iec_types.h"

   299

#else

   300

  #include "iec_std_lib.h"

   301

#endif

   302

   303

%(declare_code)s

   304

   305

/* LPCBus confnode user variables definition */

   306

%(var_decl)s

   307

   308

/* LPCBus confnode functions */

   309

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

   310

{

   311

%(init_code)s

   312

  return 0;

   313

}

   314

   315

void __cleanup_%(location_str)s(void)

   316

{

   317

}

   318

   319

void __retrieve_%(location_str)s(void)

   320

{

   321

%(retrieve_code)s

   322

}

   323

   324

void __publish_%(location_str)s(void)

   325

{

   326

%(publish_code)s

   327

}

   328

"""

   329

   330

class LPCBus(object):

   331

   332

    def __init__(self):

   333

        self.VariableLocationTree = []

   334

        self.ResetUsedLocations()

   335

        self.Icon = None

   336

   337

    def __getitem__(self, key):

   338

        if key == "children":

   339

            return self.VariableLocationTree

   340

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

   341

   342

    def CTNEnabled(self):

   343

        return None

   344

   345

    def SetIcon(self, icon):

   346

        self.Icon = icon

   347

   348

    def _GetChildBySomething(self, something, toks):

   349

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

   350

   351

    def GetBaseTypes(self):

   352

        return self.GetCTRoot().GetBaseTypes()

   353

   354

    def GetSizeOfType(self, type):

   355

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

   356

   357

    def _GetVariableLocationTree(self, current_location, infos):

   358

        if infos["type"] == LOCATION_MODULE:

   359

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

   360

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

   361

                    "type": infos["type"],

   362

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

   363

                    "icon": infos["icon"], 

   364

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

   365

        elif infos["type"] == LOCATION_GROUP:

   366

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

   367

                    "type": infos["type"],

   368

                    "location": "", 

   369

                    "icon": infos["icon"], 

   370

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

   371

        else:

   372

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

   373

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

   374

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

   375

                    "type": infos["type"],

   376

                    "size": size,

   377

                    "IEC_type": infos["IEC_type"],

   378

                    "var_name": infos["name"],

   379

                    "location": location,

   380

                    "description": infos["description"],

   381

                    "children": []}

   382

   383

    def GetVariableLocationTree(self):

   384

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

   385

                "type": LOCATION_CONFNODE,

   386

                "location": self.GetFullIEC_Channel(),

   387

                "icon": self.Icon, 

   388

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

   389

                             for child in self.VariableLocationTree]}

   390

   391

    def CTNTestModified(self):

   392

        return False

   393

   394

    def CTNMakeDir(self):

   395

        pass

   396

   397

    def CTNRequestSave(self):

   398

        return None

   399

   400

    def ResetUsedLocations(self):

   401

        self.UsedLocations = {}

   402

   403

    def _AddUsedLocation(self, parent, location):

   404

        num = location.pop(0)

   405

        if not parent.has_key(num):

   406

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

   407

        if len(location) > 0:

   408

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

   409

        else:

   410

            parent[num]["used"] = True

   411

   412

    def AddUsedLocation(self, location):

   413

        if len(location) > 0:

   414

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

   415

   416

    def _CheckLocationConflicts(self, parent, location):

   417

        num = location.pop(0)

   418

        if not parent.has_key(num):

   419

            return False

   420

        if len(location) > 0:

   421

            if parent[num]["used"]:

   422

                return True

   423

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

   424

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

   425

            return True

   426

        return False

   427

   428

    def CheckLocationConflicts(self, location):

   429

        if len(location) > 0:

   430

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

   431

        return False

   432

   433

    def CTNGenerate_C(self, buildpath, locations):

   434

        """

   435

        Generate C code

   436

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

   437

        @param locations: List of complete variables locations \

   438

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

   439

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

   440

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

   441

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

   442

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

   443

            }, ...]

   444

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

   445

        """

   446

        current_location = self.GetCurrentLocation()

   447

        # define a unique name for the generated C file

   448

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

   449

   450

        code_str = {"location_str": location_str,

   451

                    "var_decl": "",

   452

                    "declare_code": "",

   453

                    "init_code": "",

   454

                    "retrieve_code": "",

   455

                    "publish_code": "",

   456

                   }

   457

   458

        for module in _GetModuleChildren(self):

   459

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

   460

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

   461

   462

        # Adding variables

   463

        vars = []

   464

        self.ResetUsedLocations()

   465

        for location in locations:

   466

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

   467

            group = next = self

   468

            i = 0

   469

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

   470

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

   471

                if next is not None:

   472

                    i += 1

   473

                    group = next

   474

            var_loc = loc[i:]

   475

            for variable in _GetModuleChildren(group):

   476

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

   477

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

   478

#                        raise Exception, "Direction conflict in variable definition"

   479

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

   480

#                        raise Exception, "Type conflict in variable definition"

   481

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

   482

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

   483

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

   484

                        self.AddUsedLocation(location["LOC"])

   485

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

   486

                                 "Type": variable["IEC_type"],

   487

                                 "Retrieve": variable["retrieve"],

   488

                                 "Publish": variable["publish"],

   489

                                })

   490

                    break

   491

        base_types = self.GetCTRoot().GetBaseTypes()

   492

        for var in vars:

   493

            prefix = ""

   494

            if var["Type"] in base_types:

   495

                prefix = "IEC_"

   496

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

   497

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

   498

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

   499

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

   500

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

   501

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

   502

   503

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

   504

        module = open(Gen_Module_path,'w')

   505

        module.write(BUS_TEXT % code_str)

   506

        module.close()

   507

   508

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

   509

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

   510

   511

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

   512

#                          LPC CanFestival ConfNode Class

   513

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

   514

   515

if havecanfestival:

   516

   517

    DEFAULT_SETTINGS = {