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

    60

    61

if __name__ == '__main__':

    67

    68

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

    69

import features

    70

from POULibrary import POULibrary

    71

    72

class PLCLibrary(POULibrary):

    73

    def GetLibraryPath(self):

    74

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

    75

    76

features.libraries=[('LPC', lambda: PLCLibrary)]

    77

    78

    79

import connectors

    80

from LPCconnector import LPC_connector_factory

    81

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

    82

    83

import targets

    84

from LPCtarget import LPC_target 

    85

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

    86

                          "class": lambda: LPC_target,

    87

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

    88

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

    89

    90

from Beremiz import *

    91

from ProjectController import ProjectController

    92

from ConfigTreeNode import ConfigTreeNode

    93

from editors.ProjectNodeEditor import ProjectNodeEditor

    94

    95

from plcopen.structures import LOCATIONDATATYPES

    96

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

    97

                         LOCATION_VAR_INPUT, LOCATION_VAR_OUTPUT, LOCATION_VAR_MEMORY

    98

from IDEFrame import IDEFrame

    99

from dialogs import ProjectDialog

   100

   101

havecanfestival = False

   102

try:

   103

    from canfestival import RootClass as CanOpenRootClass

   104

    from canfestival.canfestival import _SlaveCTN, _NodeListCTN, NodeManager

   105

    from canfestival.NetworkEditor import NetworkEditor

   106

    from canfestival.SlaveEditor import SlaveEditor

   107

    havecanfestival = True

   108

except:

   109

    havecanfestival = False

   110

   111

SCROLLBAR_UNIT = 10

   112

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

   113

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

   114

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

   115

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

   116

   117

if wx.Platform == '__WXMSW__':

   118

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

   119

              'mono' : 'Courier New',

   120

              'helv' : 'Arial',

   121

              'other': 'Comic Sans MS',

   122

              'size' : 16,

   123

             }

   124

else:

   125

    faces = { 'times': 'Times',

   126

              'mono' : 'Courier',

   127

              'helv' : 'Helvetica',

   128

              'other': 'new century schoolbook',

   129

              'size' : 18,

   130

             }

   131

   132

# Some helpers to tweak GenBitmapTextButtons

   133

# TODO: declare customized classes instead.

   134

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

   135

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

   136

   137

def make_genbitmaptogglebutton_flat(button):

   138

    button.GetBackgroundBrush = gen_mini_GetBackgroundBrush(button)

   139

    button.labelDelta = 0

   140

    button.SetBezelWidth(0)

   141

    button.SetUseFocusIndicator(False)

   142

   143

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

   144

import wx.lib.imageutils

   145

from wx.lib.imageutils import grayOut as old_grayOut

   146

def grayOut(anImage):

   147

    if anImage.HasAlpha():

   148

        AlphaData = anImage.GetAlphaData()

   149

    else :

   150

        AlphaData = None

   151

   152

    old_grayOut(anImage)

   153

   154

    if AlphaData is not None:

   155

        anImage.SetAlphaData(AlphaData)

   156

   157

wx.lib.imageutils.grayOut = grayOut

   158

   159

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

   160

    def _GetLabelSize(self):

   161

        """ used internally """

   162

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

   163

        if not self.bmpLabel:

   164

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

   165

   166

        w_bmp = self.bmpLabel.GetWidth()+2

   167

        h_bmp = self.bmpLabel.GetHeight()+2

   168

        height = h + h_bmp

   169

        if w_bmp > w:

   170

            width = w_bmp

   171

        else:

   172

            width = w

   173

        return width, height, False

   174

   175

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

   176

        bmp = self.bmpLabel

   177

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

   178

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

   179

                bmp = self.bmpDisabled

   180

            if self.bmpFocus and self.hasFocus:

   181

                bmp = self.bmpFocus

   182

            if self.bmpSelected and not self.up:

   183

                bmp = self.bmpSelected

   184

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

   185

            if not self.up:

   186

                dw = dy = self.labelDelta

   187

            hasMask = bmp.GetMask() != None

   188

        else:

   189

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

   190

   191

        dc.SetFont(self.GetFont())

   192

        if self.IsEnabled():

   193

            dc.SetTextForeground(self.GetForegroundColour())

   194

        else:

   195

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

   196

   197

        label = self.GetLabel()

   198

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

   199

        if not self.up:

   200

            dw = dy = self.labelDelta

   201

   202

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

   203

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

   204

        if bmp !=None:

   205

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

   206

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

   207

            pos_y += bh + 2

   208

   209

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

   210

   211

   212

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

   213

#                          CANFESTIVAL CONFNODE HACK

   214

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

   215

# from canfestival import canfestival

   216

# class LPC_canfestival_config:

   217

#     def getCFLAGS(self, *args):

   218

#         return ""

   219

# 

   220

#     def getLDFLAGS(self, *args):

   221

#         return ""

   222

#         

   223

# canfestival.local_canfestival_config = LPC_canfestival_config() 

   224

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

   225

#                              LPCModule Class

   226

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

   227

   228

LOCATION_TYPES = {"I": LOCATION_VAR_INPUT,

   229

                  "Q": LOCATION_VAR_OUTPUT,

   230

                  "M": LOCATION_VAR_MEMORY}

   231

   232

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

   233

   234

LOCATION_SIZES = {}

   235

for size, types in LOCATIONDATATYPES.iteritems():

   236

    for type in types:

   237

        LOCATION_SIZES[type] = size

   238

   239

def _GetModuleChildren(module):

   240

    children = []

   241

    for child in module["children"]:

   242

        if child["type"] == LOCATION_GROUP:

   243

            children.extend(child["children"])

   244

        else:

   245

            children.append(child)

   246

    return children

   247

   248

def _GetVariables(module):

   249

    variables = []

   250

    for child in module["children"]:

   251

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

   252

            variables.extend(_GetVariables(child))

   253

        else:

   254

            variables.append(child)

   255

    return variables

   256

   257

def _GetLastModuleGroup(module):

   258

    group = module

   259

    for child in module["children"]:

   260

        if child["type"] == LOCATION_GROUP:

   261

            group = child

   262

    return group["children"]

   263

   264

def _GetModuleBySomething(module, something, toks):

   265

    for child in _GetModuleChildren(module):

   266

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

   267

            if len(toks) > 1:

   268

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

   269

            return child

   270

    return None

   271

   272

def _GetModuleVariable(module, location, direction):

   273

    for child in _GetModuleChildren(module):

   274

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

   275

            return child

   276

    return None

   277

   278

def _RemoveModuleChild(module, child):

   279

    if child in module["children"]:

   280

        module["children"].remove(child)

   281

    else:

   282

        for group in module["children"]:

   283

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

   284

                group["children"].remove(child)

   285

   286

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

   287

   288

/* LPCBus confnode includes */

   289

#include "app_glue.h"

   290

#ifdef _WINDOWS_H

   291

  #include "iec_types.h"

   292

#else

   293

  #include "iec_std_lib.h"

   294

#endif

   295

   296

%(declare_code)s

   297

   298

/* LPCBus confnode user variables definition */

   299

%(var_decl)s

   300

   301

/* LPCBus confnode functions */

   302

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

   303

{

   304

%(init_code)s

   305

  return 0;

   306

}

   307

   308

void __cleanup_%(location_str)s(void)

   309

{

   310

}

   311

   312

void __retrieve_%(location_str)s(void)

   313

{

   314

%(retrieve_code)s

   315

}

   316

   317

void __publish_%(location_str)s(void)

   318

{

   319

%(publish_code)s

   320

}

   321

"""

   322

   323

class LPCBus(object):

   324

   325

    def __init__(self):

   326

        self.VariableLocationTree = []

   327

        self.ResetUsedLocations()

   328

        self.Icon = None

   329

   330

    def __getitem__(self, key):

   331

        if key == "children":

   332

            return self.VariableLocationTree

   333

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

   334

   335

    def CTNEnabled(self):

   336

        return None

   337

   338

    def SetIcon(self, icon):

   339

        self.Icon = icon

   340

   341

    def _GetChildBySomething(self, something, toks):

   342

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

   343

   344

    def GetBaseTypes(self):

   345

        return self.GetCTRoot().GetBaseTypes()

   346

   347

    def GetSizeOfType(self, type):

   348

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

   349

   350

    def _GetVariableLocationTree(self, current_location, infos):

   351

        if infos["type"] == LOCATION_MODULE:

   352

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

   353

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

   354

                    "type": infos["type"],

   355

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

   356

                    "icon": infos["icon"], 

   357

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

   358

        elif infos["type"] == LOCATION_GROUP:

   359

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

   360

                    "type": infos["type"],

   361

                    "location": "", 

   362

                    "icon": infos["icon"], 

   363

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

   364

        else:

   365

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

   366

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

   367

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

   368

                    "type": infos["type"],

   369

                    "size": size,

   370

                    "IEC_type": infos["IEC_type"],

   371

                    "var_name": infos["name"],

   372

                    "location": location,

   373

                    "description": infos["description"],

   374

                    "children": []}

   375

   376

    def GetVariableLocationTree(self):

   377

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

   378

                "type": LOCATION_CONFNODE,

   379

                "location": self.GetFullIEC_Channel(),

   380

                "icon": self.Icon, 

   381

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

   382

                             for child in self.VariableLocationTree]}

   383

   384

    def CTNTestModified(self):

   385

        return False

   386

   387

    def CTNMakeDir(self):

   388

        pass

   389

   390

    def CTNRequestSave(self):

   391

        return None

   392

   393

    def ResetUsedLocations(self):

   394

        self.UsedLocations = {}

   395

   396

    def _AddUsedLocation(self, parent, location):

   397

        num = location.pop(0)

   398

        if not parent.has_key(num):

   399

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

   400

        if len(location) > 0:

   401

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

   402

        else:

   403

            parent[num]["used"] = True

   404

   405

    def AddUsedLocation(self, location):

   406

        if len(location) > 0:

   407

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

   408

   409

    def _CheckLocationConflicts(self, parent, location):

   410

        num = location.pop(0)

   411

        if not parent.has_key(num):

   412

            return False

   413

        if len(location) > 0:

   414

            if parent[num]["used"]:

   415

                return True

   416

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

   417

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

   418

            return True

   419

        return False

   420

   421

    def CheckLocationConflicts(self, location):

   422

        if len(location) > 0:

   423

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

   424

        return False

   425

   426

    def CTNGenerate_C(self, buildpath, locations):

   427

        """

   428

        Generate C code

   429

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

   430

        @param locations: List of complete variables locations \

   431

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

   432

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

   433

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

   434

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

   435

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

   436

            }, ...]

   437

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

   438

        """

   439

        current_location = self.GetCurrentLocation()

   440

        # define a unique name for the generated C file

   441

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

   442

   443

        code_str = {"location_str": location_str,

   444

                    "var_decl": "",

   445

                    "declare_code": "",

   446

                    "init_code": "",

   447

                    "retrieve_code": "",

   448

                    "publish_code": "",

   449

                   }

   450

   451

        for module in _GetModuleChildren(self):

   452

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

   453

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

   454

   455

        # Adding variables

   456

        vars = []

   457

        self.ResetUsedLocations()

   458

        for location in locations:

   459

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

   460

            group = next = self

   461

            i = 0

   462

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

   463

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

   464

                if next is not None:

   465

                    i += 1

   466

                    group = next

   467

            var_loc = loc[i:]

   468

            for variable in _GetModuleChildren(group):

   469

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

   470

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

   471

#                        raise Exception, "Direction conflict in variable definition"

   472

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

   473

#                        raise Exception, "Type conflict in variable definition"

   474

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

   475

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

   476

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

   477

                        self.AddUsedLocation(location["LOC"])

   478

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

   479

                                 "Type": variable["IEC_type"],

   480

                                 "Retrieve": variable["retrieve"],

   481

                                 "Publish": variable["publish"],

   482

                                })

   483

                    break

   484

        base_types = self.GetCTRoot().GetBaseTypes()

   485

        for var in vars:

   486

            prefix = ""

   487

            if var["Type"] in base_types:

   488

                prefix = "IEC_"

   489

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

   490

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

   491

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

   492

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

   493

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

   494

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

   495

   496

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

   497

        module = open(Gen_Module_path,'w')

   498

        module.write(BUS_TEXT % code_str)

   499

        module.close()

   500

   501

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

   502

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

   503

   504

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

   505

#                          LPC CanFestival ConfNode Class

   506

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

   507

   508

if havecanfestival:

   509

   510

    DEFAULT_SETTINGS = {

   511

        "CAN_Baudrate": "125K",

   512

        "Slave_NodeId": 2,

   513

        "Master_NodeId": 1,

   514

    }

   515

   516

    class LPCSlaveEditor(SlaveEditor):

   517

        SHOW_BASE_PARAMS = False

   518