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

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

    62

import features

    63

from POULibrary import POULibrary

    64

    65

class PLCLibrary(POULibrary):

    66

    def GetLibraryPath(self):

    67

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

    68

    69

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

    70

    71

    72

import connectors

    73

from LPCconnector import LPC_connector_factory

    74

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

    75

    76

import targets

    77

from LPCtarget import LPC_target 

    78

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

    79

                          "class": lambda: LPC_target,

    80

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

    81

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

    82

    83

from Beremiz import *

    84

from ProjectController import ProjectController

    85

from ConfigTreeNode import ConfigTreeNode

    87

    88

from plcopen.structures import LOCATIONDATATYPES

    89

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

    90

                         LOCATION_VAR_INPUT, LOCATION_VAR_OUTPUT, LOCATION_VAR_MEMORY

    93

    94

havecanfestival = False

    95

try:

    96

    from canfestival import RootClass as CanOpenRootClass

    97

    from canfestival.canfestival import _SlaveCTN, _NodeListCTN, NodeManager

    98

    from canfestival.NetworkEditor import NetworkEditor

    99

    from canfestival.SlaveEditor import SlaveEditor

   100

    havecanfestival = True

   101

except:

   102

    havecanfestival = False

   103

   104

SCROLLBAR_UNIT = 10

   105

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

   106

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

   107

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

   108

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

   109

   110

if wx.Platform == '__WXMSW__':

   111

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

   112

              'mono' : 'Courier New',

   113

              'helv' : 'Arial',

   114

              'other': 'Comic Sans MS',

   115

              'size' : 16,

   116

             }

   117

else:

   118

    faces = { 'times': 'Times',

   119

              'mono' : 'Courier',

   120

              'helv' : 'Helvetica',

   121

              'other': 'new century schoolbook',

   122

              'size' : 18,

   123

             }

   124

   125

# Some helpers to tweak GenBitmapTextButtons

   126

# TODO: declare customized classes instead.

   127

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

   128

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

   129

   130

def make_genbitmaptogglebutton_flat(button):

   131

    button.GetBackgroundBrush = gen_mini_GetBackgroundBrush(button)

   132

    button.labelDelta = 0

   133

    button.SetBezelWidth(0)

   134

    button.SetUseFocusIndicator(False)

   135

   136

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

   137

import wx.lib.imageutils

   138

from wx.lib.imageutils import grayOut as old_grayOut

   139

def grayOut(anImage):

   140

    if anImage.HasAlpha():

   141

        AlphaData = anImage.GetAlphaData()

   142

    else :

   143

        AlphaData = None

   144

   145

    old_grayOut(anImage)

   146

   147

    if AlphaData is not None:

   148

        anImage.SetAlphaData(AlphaData)

   149

   150

wx.lib.imageutils.grayOut = grayOut

   151

   152

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

   153

    def _GetLabelSize(self):

   154

        """ used internally """

   155

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

   156

        if not self.bmpLabel:

   157

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

   158

   159

        w_bmp = self.bmpLabel.GetWidth()+2

   160

        h_bmp = self.bmpLabel.GetHeight()+2

   161

        height = h + h_bmp

   162

        if w_bmp > w:

   163

            width = w_bmp

   164

        else:

   165

            width = w

   166

        return width, height, False

   167

   168

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

   169

        bmp = self.bmpLabel

   170

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

   171

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

   172

                bmp = self.bmpDisabled

   173

            if self.bmpFocus and self.hasFocus:

   174

                bmp = self.bmpFocus

   175

            if self.bmpSelected and not self.up:

   176

                bmp = self.bmpSelected

   177

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

   178

            if not self.up:

   179

                dw = dy = self.labelDelta

   180

            hasMask = bmp.GetMask() != None

   181

        else:

   182

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

   183

   184

        dc.SetFont(self.GetFont())

   185

        if self.IsEnabled():

   186

            dc.SetTextForeground(self.GetForegroundColour())

   187

        else:

   188

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

   189

   190

        label = self.GetLabel()

   191

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

   192

        if not self.up:

   193

            dw = dy = self.labelDelta

   194

   195

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

   196

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

   197

        if bmp !=None:

   198

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

   199

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

   200

            pos_y += bh + 2

   201

   202

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

   203

   204

   205

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

   206

#                          CANFESTIVAL CONFNODE HACK

   207

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

   208

# from canfestival import canfestival

   209

# class LPC_canfestival_config:

   210

#     def getCFLAGS(self, *args):

   211

#         return ""

   212

# 

   213

#     def getLDFLAGS(self, *args):

   214

#         return ""

   215

#         

   216

# canfestival.local_canfestival_config = LPC_canfestival_config() 

   217

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

   218

#                              LPCModule Class

   219

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

   220

   221

LOCATION_TYPES = {"I": LOCATION_VAR_INPUT,

   222

                  "Q": LOCATION_VAR_OUTPUT,

   223

                  "M": LOCATION_VAR_MEMORY}

   224

   225

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

   226

   227

LOCATION_SIZES = {}

   228

for size, types in LOCATIONDATATYPES.iteritems():

   229

    for type in types:

   230

        LOCATION_SIZES[type] = size

   231

   232

def _GetModuleChildren(module):

   233

    children = []

   234

    for child in module["children"]:

   235

        if child["type"] == LOCATION_GROUP:

   236

            children.extend(child["children"])

   237

        else:

   238

            children.append(child)

   239

    return children

   240

   241

def _GetVariables(module):

   242

    variables = []

   243

    for child in module["children"]:

   244

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

   245

            variables.extend(_GetVariables(child))

   246

        else:

   247

            variables.append(child)

   248

    return variables

   249

   250

def _GetLastModuleGroup(module):

   251

    group = module

   252

    for child in module["children"]:

   253

        if child["type"] == LOCATION_GROUP:

   254

            group = child

   255

    return group["children"]

   256

   257

def _GetModuleBySomething(module, something, toks):

   258

    for child in _GetModuleChildren(module):

   259

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

   260

            if len(toks) > 1:

   261

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

   262

            return child

   263

    return None

   264

   265

def _GetModuleVariable(module, location, direction):

   266

    for child in _GetModuleChildren(module):

   267

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

   268

            return child

   269

    return None

   270

   271

def _RemoveModuleChild(module, child):

   272

    if child in module["children"]:

   273

        module["children"].remove(child)

   274

    else:

   275

        for group in module["children"]:

   276

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

   277

                group["children"].remove(child)

   278

   279

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

   280

   281

/* LPCBus confnode includes */

   282

#include "app_glue.h"

   283

#ifdef _WINDOWS_H

   284

  #include "iec_types.h"

   285

#else

   286

  #include "iec_std_lib.h"

   287

#endif

   288

   289

%(declare_code)s

   290

   291

/* LPCBus confnode user variables definition */

   292

%(var_decl)s

   293

   294

/* LPCBus confnode functions */

   295

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

   296

{

   297

%(init_code)s

   298

  return 0;

   299

}

   300

   301

void __cleanup_%(location_str)s(void)

   302

{

   303

}

   304

   305

void __retrieve_%(location_str)s(void)

   306

{

   307

%(retrieve_code)s

   308

}

   309

   310

void __publish_%(location_str)s(void)

   311

{

   312

%(publish_code)s

   313

}

   314

"""

   315

   316

class LPCBus(object):

   317

   318

    def __init__(self):

   319

        self.VariableLocationTree = []

   320

        self.ResetUsedLocations()

   321

        self.Icon = None

   322

   323

    def __getitem__(self, key):

   324

        if key == "children":

   325

            return self.VariableLocationTree

   326

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

   327

   328

    def CTNEnabled(self):

   329

        return None

   330

   331

    def SetIcon(self, icon):

   332

        self.Icon = icon

   333

   334

    def _GetChildBySomething(self, something, toks):

   335

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

   336

   337

    def GetBaseTypes(self):

   338

        return self.GetCTRoot().GetBaseTypes()

   339

   340

    def GetSizeOfType(self, type):

   341

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

   342

   343

    def _GetVariableLocationTree(self, current_location, infos):

   344

        if infos["type"] == LOCATION_MODULE:

   345

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

   346

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

   347

                    "type": infos["type"],

   348

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

   349

                    "icon": infos["icon"], 

   350

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

   351

        elif infos["type"] == LOCATION_GROUP:

   352

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

   353

                    "type": infos["type"],

   354

                    "location": "", 

   355

                    "icon": infos["icon"], 

   356

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

   357

        else:

   358

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

   359

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

   360

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

   361

                    "type": infos["type"],

   362

                    "size": size,

   363

                    "IEC_type": infos["IEC_type"],

   364

                    "var_name": infos["name"],

   365

                    "location": location,

   366

                    "description": infos["description"],

   367

                    "children": []}

   368

   369

    def GetVariableLocationTree(self):

   370

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

   371

                "type": LOCATION_CONFNODE,

   372

                "location": self.GetFullIEC_Channel(),

   373

                "icon": self.Icon, 

   374

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

   375

                             for child in self.VariableLocationTree]}

   376

   377

    def CTNTestModified(self):

   378

        return False

   379

   380

    def CTNMakeDir(self):

   381

        pass

   382

   383

    def CTNRequestSave(self):

   384

        return None

   385

   386

    def ResetUsedLocations(self):

   387

        self.UsedLocations = {}

   388

   389

    def _AddUsedLocation(self, parent, location):

   390

        num = location.pop(0)

   391

        if not parent.has_key(num):

   392

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

   393

        if len(location) > 0:

   394

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

   395

        else:

   396

            parent[num]["used"] = True

   397

   398

    def AddUsedLocation(self, location):

   399

        if len(location) > 0:

   400

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

   401

   402

    def _CheckLocationConflicts(self, parent, location):

   403

        num = location.pop(0)

   404

        if not parent.has_key(num):

   405

            return False

   406

        if len(location) > 0:

   407

            if parent[num]["used"]:

   408

                return True

   409

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

   410

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

   411

            return True

   412

        return False

   413

   414

    def CheckLocationConflicts(self, location):

   415

        if len(location) > 0:

   416

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

   417

        return False

   418

   419

    def CTNGenerate_C(self, buildpath, locations):

   420

        """

   421

        Generate C code

   422

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

   423

        @param locations: List of complete variables locations \

   424

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

   425

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

   426

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

   427

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

   428

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

   429

            }, ...]

   430

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

   431

        """

   432

        current_location = self.GetCurrentLocation()

   433

        # define a unique name for the generated C file

   434

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

   435

   436

        code_str = {"location_str": location_str,

   437

                    "var_decl": "",

   438

                    "declare_code": "",

   439

                    "init_code": "",

   440

                    "retrieve_code": "",

   441

                    "publish_code": "",

   442

                   }

   443

   444

        for module in _GetModuleChildren(self):

   445

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

   446

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

   447

   448

        # Adding variables

   449

        vars = []

   450

        self.ResetUsedLocations()

   451

        for location in locations:

   452

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

   453

            group = next = self

   454

            i = 0

   455

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

   456

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

   457

                if next is not None:

   458

                    i += 1

   459

                    group = next

   460

            var_loc = loc[i:]

   461

            for variable in _GetModuleChildren(group):

   462

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

   463

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

   464

#                        raise Exception, "Direction conflict in variable definition"

   465

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

   466

#                        raise Exception, "Type conflict in variable definition"

   467

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

   468

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

   469

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

   470

                        self.AddUsedLocation(location["LOC"])

   471

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

   472

                                 "Type": variable["IEC_type"],

   473

                                 "Retrieve": variable["retrieve"],

   474

                                 "Publish": variable["publish"],

   475

                                })

   476

                    break

   477

        base_types = self.GetCTRoot().GetBaseTypes()

   478

        for var in vars:

   479

            prefix = ""

   480

            if var["Type"] in base_types:

   481

                prefix = "IEC_"

   482

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

   483

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

   484

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

   485

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

   486

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

   487

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

   488

   489

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

   490

        module = open(Gen_Module_path,'w')

   491

        module.write(BUS_TEXT % code_str)

   492

        module.close()

   493

   494

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

   495

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

   496

   497

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

   498

#                          LPC CanFestival ConfNode Class

   499

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

   500

   501

if havecanfestival:

   502

   503

    DEFAULT_SETTINGS = {

   504

        "CAN_Baudrate": "125K",

   505

        "Slave_NodeId": 2,

   506

        "Master_NodeId": 1,

   507

    }

   508

   509

    class LPCSlaveEditor(SlaveEditor):

   510

        SHOW_BASE_PARAMS = False

   511

   512

    class LPCCanOpenSlave(_SlaveCTN):

   513

        XSD = """<?xml version="1.0" encoding="ISO-8859-1" ?>

   514

        <xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema">

   515

          <xsd:element name="CanFestivalSlaveNode">

   516

            <xsd:complexType>

   517

              <xsd:attribute name="CAN_Baudrate" type="xsd:string" use="optional" default="%(CAN_Baudrate)s"/>

   518

              <xsd:attribute name="NodeId" type="xsd:string" use="optional" default="%(Slave_NodeId)d"/>

   519

              <xsd:attribute name="Sync_Align" type="xsd:integer" use="optional" default="0"/>