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

    80

features.libraries=[

    81

    ('Native', 'NativeLib.NativeLibrary'),

    82

    ('LPC', lambda: PLCLibrary)]

    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

   140

   141

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

   142

#                          CANFESTIVAL CONFNODE HACK

   143

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

   144

# from canfestival import canfestival

   145

# class LPC_canfestival_config:

   146

#     def getCFLAGS(self, *args):

   147

#         return ""

   148

# 

   149

#     def getLDFLAGS(self, *args):

   150

#         return ""

   151

#         

   152

# canfestival.local_canfestival_config = LPC_canfestival_config() 

   153

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

   154

#                              LPCModule Class

   155

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

   156

   157

LOCATION_TYPES = {"I": LOCATION_VAR_INPUT,

   158

                  "Q": LOCATION_VAR_OUTPUT,

   159

                  "M": LOCATION_VAR_MEMORY}

   160

   161

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

   162

   163

LOCATION_SIZES = {}

   164

for size, types in LOCATIONDATATYPES.iteritems():

   165

    for type in types:

   166

        LOCATION_SIZES[type] = size

   167

   168

def _GetModuleChildren(module):

   169

    children = []

   170

    for child in module["children"]:

   171

        if child["type"] == LOCATION_GROUP:

   172

            children.extend(child["children"])

   173

        else:

   174

            children.append(child)

   175

    return children

   176

   177

def _GetVariables(module):

   178

    variables = []

   179

    for child in module["children"]:

   180

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

   181

            variables.extend(_GetVariables(child))

   182

        else:

   183

            variables.append(child)

   184

    return variables

   185

   186

def _GetLastModuleGroup(module):

   187

    group = module

   188

    for child in module["children"]:

   189

        if child["type"] == LOCATION_GROUP:

   190

            group = child

   191

    return group["children"]

   192

   193

def _GetModuleBySomething(module, something, toks):

   194

    for child in _GetModuleChildren(module):

   195

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

   196

            if len(toks) > 1:

   197

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

   198

            return child

   199

    return None

   200

   201

def _GetModuleVariable(module, location, direction):

   202

    for child in _GetModuleChildren(module):

   203

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

   204

            return child

   205

    return None

   206

   207

def _RemoveModuleChild(module, child):

   208

    if child in module["children"]:

   209

        module["children"].remove(child)

   210

    else:

   211

        for group in module["children"]:

   212

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

   213

                group["children"].remove(child)

   214

   215

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

   216

   217

/* LPCBus confnode includes */

   218

#include "app_glue.h"

   219

#ifdef _WINDOWS_H

   220

  #include "iec_types.h"

   221

#else

   222

  #include "iec_std_lib.h"

   223

#endif

   224

   225

%(declare_code)s

   226

   227

/* LPCBus confnode user variables definition */

   228

%(var_decl)s

   229

   230

/* LPCBus confnode functions */

   231

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

   232

{

   233

%(init_code)s

   234

  return 0;

   235

}

   236

   237

void __cleanup_%(location_str)s(void)

   238

{

   239

}

   240

   241

void __retrieve_%(location_str)s(void)

   242

{

   243

%(retrieve_code)s

   244

}

   245

   246

void __publish_%(location_str)s(void)

   247

{

   248

%(publish_code)s

   249

}

   250

"""

   251

   252

class LPCBus(object):

   253

   254

    def __init__(self):

   255

        self.VariableLocationTree = []

   256

        self.ResetUsedLocations()

   257

        self.Icon = None

   258

   259

    def __getitem__(self, key):

   260

        if key == "children":

   261

            return self.VariableLocationTree

   262

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

   263

   264

    def CTNEnabled(self):

   265

        return None

   266

   267

    def SetIcon(self, icon):

   268

        self.Icon = icon

   269

   270

    def _GetChildBySomething(self, something, toks):

   271

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

   272

   273

    def GetBaseTypes(self):

   274

        return self.GetCTRoot().GetBaseTypes()

   275

   276

    def GetSizeOfType(self, type):

   277

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

   278

   279

    def _GetVariableLocationTree(self, current_location, infos):

   280

        if infos["type"] == LOCATION_MODULE:

   281

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

   282

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

   283

                    "type": infos["type"],

   284

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

   285

                    "icon": infos["icon"], 

   286

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

   287

        elif infos["type"] == LOCATION_GROUP:

   288

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

   289

                    "type": infos["type"],

   290

                    "location": "", 

   291

                    "icon": infos["icon"], 

   292

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

   293

        else:

   294

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

   295

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

   296

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

   297

                    "type": infos["type"],

   298

                    "size": size,

   299

                    "IEC_type": infos["IEC_type"],

   300

                    "var_name": infos["name"],

   301

                    "location": location,

   302

                    "description": infos["description"],

   303

                    "children": []}

   304

   305

    def GetVariableLocationTree(self):

   306

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

   307

                "type": LOCATION_CONFNODE,

   308

                "location": self.GetFullIEC_Channel(),

   309

                "icon": self.Icon, 

   310

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

   311

                             for child in self.VariableLocationTree]}

   312

   313

    def CTNTestModified(self):

   314

        return False

   315

   316

    def CTNMakeDir(self):

   317

        pass

   318

   319

    def CTNRequestSave(self, from_project_path=None):

   320

        return None

   321

   322

    def ResetUsedLocations(self):

   323

        self.UsedLocations = {}

   324

   325

    def _AddUsedLocation(self, parent, location):

   326

        num = location.pop(0)

   327

        if not parent.has_key(num):

   328

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

   329

        if len(location) > 0:

   330

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

   331

        else:

   332

            parent[num]["used"] = True

   333

   334

    def AddUsedLocation(self, location):

   335

        if len(location) > 0:

   336

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

   337

   338

    def _CheckLocationConflicts(self, parent, location):

   339

        num = location.pop(0)

   340

        if not parent.has_key(num):

   341

            return False

   342

        if len(location) > 0:

   343

            if parent[num]["used"]:

   344

                return True

   345

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

   346

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

   347

            return True

   348

        return False

   349

   350

    def CheckLocationConflicts(self, location):

   351

        if len(location) > 0:

   352

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

   353

        return False

   354

   355

    def CTNGenerate_C(self, buildpath, locations):

   356

        """

   357

        Generate C code

   358

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

   359

        @param locations: List of complete variables locations \

   360

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

   361

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

   362

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

   363

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

   364

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

   365

            }, ...]

   366

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

   367

        """

   368

        current_location = self.GetCurrentLocation()

   369

        # define a unique name for the generated C file

   370

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

   371

   372

        code_str = {"location_str": location_str,

   373

                    "var_decl": "",

   374

                    "declare_code": "",

   375

                    "init_code": "",

   376

                    "retrieve_code": "",

   377

                    "publish_code": "",

   378

                   }

   379

   380

        for module in _GetModuleChildren(self):

   381

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

   382

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

   383

   384

        # Adding variables

   385

        vars = []

   386

        self.ResetUsedLocations()

   387

        for location in locations:

   388

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

   389

            group = next = self

   390

            i = 0

   391

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

   392

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

   393

                if next is not None:

   394

                    i += 1

   395

                    group = next

   396

            var_loc = loc[i:]

   397

            for variable in _GetModuleChildren(group):

   398

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

   399

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

   400

#                        raise Exception, "Direction conflict in variable definition"

   401

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

   402

#                        raise Exception, "Type conflict in variable definition"

   403

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

   404

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

   405

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

   406

                        self.AddUsedLocation(location["LOC"])

   407

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

   408

                                 "Type": variable["IEC_type"],

   409

                                 "Retrieve": variable["retrieve"],

   410

                                 "Publish": variable["publish"],

   411

                                })

   412

                    break

   413

        base_types = self.GetCTRoot().GetBaseTypes()

   414

        for var in vars:

   415

            prefix = ""

   416

            if var["Type"] in base_types:

   417

                prefix = "IEC_"

   418

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

   419

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

   420

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

   421

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

   422

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

   423

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

   424

   425

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

   426

        module = open(Gen_Module_path,'w')

   427

        module.write(BUS_TEXT % code_str)

   428

        module.close()

   429

   430

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

   431

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

   432

   433

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

   434

#                          LPC CanFestival ConfNode Class

   435

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

   436

   437

if havecanfestival:

   438

   439

    DEFAULT_SETTINGS = {

   440

        "CAN_Baudrate": "125K",

   441

        "Slave_NodeId": 2,

   442

        "Master_NodeId": 1,

   443

    }

   444

   445

    class LPCSlaveEditor(SlaveEditor):

   446

        SHOW_BASE_PARAMS = False

   447

   448

    class LPCCanOpenSlave(_SlaveCTN):

   449

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

   450

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

   451

          <xsd:element name="CanFestivalSlaveNode">

   452

            <xsd:complexType>

   453

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

   454

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

   455

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

   456

              <xsd:attribute name="Sync_Align_Ratio" use="optional" default="50">

   457

                <xsd:simpleType>

   458

                    <xsd:restriction base="xsd:integer">

   459

                        <xsd:minInclusive value="1"/>

   460

                        <xsd:maxInclusive value="99"/>

   461

                    </xsd:restriction>

   462

                </xsd:simpleType>

   463

              </xsd:attribute>

   464

            </xsd:complexType>

   465

          </xsd:element>

   466

        </xsd:schema>

   467

        """ % DEFAULT_SETTINGS

   468

   469

        EditorType = LPCSlaveEditor

   470

   471

        def __init__(self):

   472

            # TODO change netname when name change

   473

            NodeManager.__init__(self)

   474

            odfilepath = self.GetSlaveODPath()

   475

            if(os.path.isfile(odfilepath)):

   476

                self.OpenFileInCurrent(odfilepath)

   477

            else:

   478

                self.CreateNewNode("SlaveNode",  # Name - will be changed at build time

   479

                                   0x00,         # NodeID - will be changed at build time

   480

                                   "slave",      # Type

   481

                                   "",           # description 

   482

                                   "None",       # profile

   483

                                   "", # prfile filepath

   484

                                   "heartbeat",  # NMT

   485

                                   [])           # options

   486

                self.OnCTNSave()

   487

   488

        def GetCanDevice(self):

   489

            return str(self.BaseParams.getIEC_Channel())

   490

   491

        ConfNodeMethods = [

   492

            {"bitmap" : "NetworkEdit",

   493

             "name" : _("Edit slave"), 

   494

             "tooltip" : _("Edit CanOpen slave with ObjdictEdit"),

   495

             "method" : "_OpenView"},

   496

        ] + _SlaveCTN.ConfNodeMethods

   497

   498

    class LPCNetworkEditor(NetworkEditor):

   499

        SHOW_BASE_PARAMS = False

   500

   501

    class LPCCanOpenMaster(_NodeListCTN):

   502

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

   503

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

   504

          <xsd:element name="CanFestivalNode">

   505

            <xsd:complexType>

   506

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

   507

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

   508

              <xsd:attribute name="Sync_TPDOs" type="xsd:boolean" use="optional" default="true"/>

   509

            </xsd:complexType>

   510

          </xsd:element>

   511

        </xsd:schema>

   512

        """ % DEFAULT_SETTINGS

   513

   514

        EditorType = LPCNetworkEditor

   515

   516

        def GetCanDevice(self):

   517

            return str(self.BaseParams.getIEC_Channel())

   518

   519

        ConfNodeMethods = [

   520