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

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

    13

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

    14

_beremiz_folder = os.path.join(_dist_folder, "beremiz")

    15

sys.path.append(_beremiz_folder)

    16

    17

def Bpath(*args):

    18

    return os.path.join(CWD,*args)

    19

    20

if __name__ == '__main__':

    21

    def usage():

    22

        print "\nUsage of LPCManager.py :"

    23

        print "\n   %s Projectpath Buildpath port [arch]\n"%sys.argv[0]

    24

    25

    try:

    26

        opts, args = getopt.getopt(sys.argv[1:], "h", ["help"])

    27

    except getopt.GetoptError:

    28

        # print help information and exit:

    29

        usage()

    30

        sys.exit(2)

    31

    32

    for o, a in opts:

    33

        if o in ("-h", "--help"):

    34

            usage()

    35

            sys.exit()

    36

    37

    if len(args) < 3 or len(args) > 4:

    38

        usage()

    39

        sys.exit()

    40

    else:

    41

        projectOpen = args[0]

    42

        buildpath = args[1]

    43

        try:

    44

            port = int(args[2])

    45

        except:

    46

            usage()

    47

            sys.exit()

    48

        if len(args) > 3:

    49

            arch = args[3]

    50

        else:

    51

            arch = "MC8"

    52

    53

    __builtin__.__dict__["BMZ_DBG"] = os.path.exists("LPC_DEBUG")

    54

    55

    app = wx.PySimpleApp(redirect=BMZ_DBG)

    56

    app.SetAppName('beremiz')

    57

    wx.InitAllImageHandlers()

    58

    59

    from util.misc import InstallLocalRessources

    60

    InstallLocalRessources(_beremiz_folder)

    61

    62

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

    63

import features

    64

from POULibrary import POULibrary

    65

    66

class PLCLibrary(POULibrary):

    67

    def GetLibraryPath(self):

    68

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

    69

    70

features.libraries=[

    71

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

    72

    ('LPC', lambda: PLCLibrary)]

    73

    74

    75

import connectors

    76

from LPCconnector import LPC_connector_factory

    77

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

    78

    79

import targets

    80

from LPCtarget import LPC_target 

    81

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

    82

                          "class": lambda: LPC_target,

    83

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

    84

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

    85

    86

from Beremiz import *

    87

from ProjectController import ProjectController

    88

from ConfigTreeNode import ConfigTreeNode

    89

from editors.ProjectNodeEditor import ProjectNodeEditor

    90

    91

from plcopen.structures import LOCATIONDATATYPES

    92

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

    93

                         LOCATION_VAR_INPUT, LOCATION_VAR_OUTPUT, LOCATION_VAR_MEMORY

    94

from IDEFrame import IDEFrame

    95

from dialogs import ProjectDialog

    96

from controls import TextCtrlAutoComplete

    97

    98

havecanfestival = False

    99

try:

   100

    from canfestival import RootClass as CanOpenRootClass

   101

    from canfestival.canfestival import _SlaveCTN, _NodeListCTN, NodeManager

   102

    from canfestival.NetworkEditor import NetworkEditor

   103

    from canfestival.SlaveEditor import SlaveEditor

   104

    havecanfestival = True

   105

except:

   106

    havecanfestival = False

   107

   108

SCROLLBAR_UNIT = 10

   109

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

   110

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

   111

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

   112

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

   113

   114

if wx.Platform == '__WXMSW__':

   115

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

   116

              'mono' : 'Courier New',

   117

              'helv' : 'Arial',

   118

              'other': 'Comic Sans MS',

   119

              'size' : 16,

   120

             }

   121

else:

   122

    faces = { 'times': 'Times',

   123

              'mono' : 'Courier',

   124

              'helv' : 'Helvetica',

   125

              'other': 'new century schoolbook',

   126

              'size' : 18,

   127

             }

   128

   129

from editors.ConfTreeNodeEditor import GenBitmapTextButton

   130

   131

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

   132

#                          CANFESTIVAL CONFNODE HACK

   133

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

   134

# from canfestival import canfestival

   135

# class LPC_canfestival_config:

   136

#     def getCFLAGS(self, *args):

   137

#         return ""

   138

# 

   139

#     def getLDFLAGS(self, *args):

   140

#         return ""

   141

#         

   142

# canfestival.local_canfestival_config = LPC_canfestival_config() 

   143

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

   144

#                              LPCModule Class

   145

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

   146

   147

LOCATION_TYPES = {"I": LOCATION_VAR_INPUT,

   148

                  "Q": LOCATION_VAR_OUTPUT,

   149

                  "M": LOCATION_VAR_MEMORY}

   150

   151

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

   152

   153

LOCATION_SIZES = {}

   154

for size, types in LOCATIONDATATYPES.iteritems():

   155

    for type in types:

   156

        LOCATION_SIZES[type] = size

   157

   158

def _GetModuleChildren(module):

   159

    children = []

   160

    for child in module["children"]:

   161

        if child["type"] == LOCATION_GROUP:

   162

            children.extend(child["children"])

   163

        else:

   164

            children.append(child)

   165

    return children

   166

   167

def _GetVariables(module):

   168

    variables = []

   169

    for child in module["children"]:

   170

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

   171

            variables.extend(_GetVariables(child))

   172

        else:

   173

            variables.append(child)

   174

    return variables

   175

   176

def _GetLastModuleGroup(module):

   177

    group = module

   178

    for child in module["children"]:

   179

        if child["type"] == LOCATION_GROUP:

   180

            group = child

   181

    return group["children"]

   182

   183

def _GetModuleBySomething(module, something, toks):

   184

    for child in _GetModuleChildren(module):

   185

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

   186

            if len(toks) > 1:

   187

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

   188

            return child

   189

    return None

   190

   191

def _GetModuleVariable(module, location, direction):

   192

    for child in _GetModuleChildren(module):

   193

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

   194

            return child

   195

    return None

   196

   197

def _RemoveModuleChild(module, child):

   198

    if child in module["children"]:

   199

        module["children"].remove(child)

   200

    else:

   201

        for group in module["children"]:

   202

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

   203

                group["children"].remove(child)

   204

   205

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

   206

   207

/* LPCBus confnode includes */

   208

#include "app_glue.h"

   209

#ifdef _WINDOWS_H

   210

  #include "iec_types.h"

   211

#else

   212

  #include "iec_std_lib.h"

   213

#endif

   214

   215

%(declare_code)s

   216

   217

/* LPCBus confnode user variables definition */

   218

%(var_decl)s

   219

   220

/* LPCBus confnode functions */

   221

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

   222

{

   223

%(init_code)s

   224

  return 0;

   225

}

   226

   227

void __cleanup_%(location_str)s(void)

   228

{

   229

}

   230

   231

void __retrieve_%(location_str)s(void)

   232

{

   233

%(retrieve_code)s

   234

}

   235

   236

void __publish_%(location_str)s(void)

   237

{

   238

%(publish_code)s

   239

}

   240

"""

   241

   242

class LPCBus(object):

   243

   244

    def __init__(self):

   245

        self.VariableLocationTree = []

   246

        self.ResetUsedLocations()

   247

        self.Icon = None

   248

   249

    def __getitem__(self, key):

   250

        if key == "children":

   251

            return self.VariableLocationTree

   252

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

   253

   254

    def CTNEnabled(self):

   255

        return None

   256

   257

    def SetIcon(self, icon):

   258

        self.Icon = icon

   259

   260

    def _GetChildBySomething(self, something, toks):

   261

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

   262

   263

    def GetBaseTypes(self):

   264

        return self.GetCTRoot().GetBaseTypes()

   265

   266

    def GetSizeOfType(self, type):

   267

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

   268

   269

    def _GetVariableLocationTree(self, current_location, infos):

   270

        if infos["type"] == LOCATION_MODULE:

   271

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

   272

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

   273

                    "type": infos["type"],

   274

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

   275

                    "icon": infos["icon"], 

   276

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

   277

        elif infos["type"] == LOCATION_GROUP:

   278

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

   279

                    "type": infos["type"],

   280

                    "location": "", 

   281

                    "icon": infos["icon"], 

   282

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

   283

        else:

   284

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

   285

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

   286

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

   287

                    "type": infos["type"],

   288

                    "size": size,

   289

                    "IEC_type": infos["IEC_type"],

   290

                    "var_name": infos["name"],

   291

                    "location": location,

   292

                    "description": infos["description"],

   293

                    "children": []}

   294

   295

    def GetVariableLocationTree(self):

   296

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

   297

                "type": LOCATION_CONFNODE,

   298

                "location": self.GetFullIEC_Channel(),

   299

                "icon": self.Icon, 

   300

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

   301

                             for child in self.VariableLocationTree]}

   302

   303

    def CTNTestModified(self):

   304

        return False

   305

   306

    def CTNMakeDir(self):

   307

        pass

   308

   309

    def CTNRequestSave(self, from_project_path=None):

   310

        return None

   311

   312

    def ResetUsedLocations(self):

   313

        self.UsedLocations = {}

   314

   315

    def _AddUsedLocation(self, parent, location):

   316

        num = location.pop(0)

   317

        if not parent.has_key(num):

   318

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

   319

        if len(location) > 0:

   320

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

   321

        else:

   322

            parent[num]["used"] = True

   323

   324

    def AddUsedLocation(self, location):

   325

        if len(location) > 0:

   326

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

   327

   328

    def _CheckLocationConflicts(self, parent, location):

   329

        num = location.pop(0)

   330

        if not parent.has_key(num):

   331

            return False

   332

        if len(location) > 0:

   333

            if parent[num]["used"]:

   334

                return True

   335

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

   336

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

   337

            return True

   338

        return False

   339

   340

    def CheckLocationConflicts(self, location):

   341

        if len(location) > 0:

   342

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

   343

        return False

   344

   345

    def CTNGenerate_C(self, buildpath, locations):

   346

        """

   347

        Generate C code

   348

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

   349

        @param locations: List of complete variables locations \

   350

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

   351

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

   352

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

   353

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

   354

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

   355

            }, ...]

   356

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

   357

        """

   358

        current_location = self.GetCurrentLocation()

   359

        # define a unique name for the generated C file

   360

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

   361

   362

        code_str = {"location_str": location_str,

   363

                    "var_decl": "",

   364

                    "declare_code": "",

   365

                    "init_code": "",

   366

                    "retrieve_code": "",

   367

                    "publish_code": "",

   368

                   }

   369

   370

        for module in _GetModuleChildren(self):

   371

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

   372

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

   373

   374

        # Adding variables

   375

        vars = []

   376

        self.ResetUsedLocations()

   377

        for location in locations:

   378

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

   379

            group = next = self

   380

            i = 0

   381

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

   382

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

   383

                if next is not None:

   384

                    i += 1

   385

                    group = next

   386

            var_loc = loc[i:]

   387

            for variable in _GetModuleChildren(group):

   388

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

   389

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

   390

#                        raise Exception, "Direction conflict in variable definition"

   391

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

   392

#                        raise Exception, "Type conflict in variable definition"

   393

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

   394

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

   395

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

   396

                        self.AddUsedLocation(location["LOC"])

   397

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

   398

                                 "Type": variable["IEC_type"],

   399

                                 "Retrieve": variable["retrieve"],

   400

                                 "Publish": variable["publish"],

   401

                                })

   402

                    break

   403

        base_types = self.GetCTRoot().GetBaseTypes()

   404

        for var in vars:

   405

            prefix = ""

   406

            if var["Type"] in base_types:

   407

                prefix = "IEC_"

   408

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

   409

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

   410

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

   411

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

   412

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

   413

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

   414

   415

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

   416

        module = open(Gen_Module_path,'w')

   417

        module.write(BUS_TEXT % code_str)

   418

        module.close()

   419

   421

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

   422

   423

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

   424

#                          LPC CanFestival ConfNode Class

   425

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

   426

   427

if havecanfestival:

   428

   429

    DEFAULT_SETTINGS = {

   430

        "CAN_Baudrate": "125K",

   431

        "Slave_NodeId": 2,

   432

        "Master_NodeId": 1,

   433

    }

   434

   435

    class LPCSlaveEditor(SlaveEditor):

   436

        SHOW_BASE_PARAMS = False

   437

   438

    class LPCCanOpenSlave(_SlaveCTN):

   439

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

   440

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

   441

          <xsd:element name="CanFestivalSlaveNode">

   442

            <xsd:complexType>

   443

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

   444

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

   445

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

   446

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

   447

                <xsd:simpleType>

   448

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

   449

                        <xsd:minInclusive value="1"/>

   450

                        <xsd:maxInclusive value="99"/>

   451

                    </xsd:restriction>

   452

                </xsd:simpleType>

   453

              </xsd:attribute>

   454

            </xsd:complexType>

   455

          </xsd:element>

   456

        </xsd:schema>

   457

        """ % DEFAULT_SETTINGS

   458

   459

        EditorType = LPCSlaveEditor

   460

   461

        def __init__(self):

   462

            # TODO change netname when name change

   463

            NodeManager.__init__(self)

   464

            odfilepath = self.GetSlaveODPath()

   465

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

   466

                self.OpenFileInCurrent(odfilepath)

   467

            else:

   468

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

   469

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

   470

                                   "slave",      # Type

   471

                                   "",           # description 

   472

                                   "None",       # profile

   473

                                   "", # prfile filepath

   474

                                   "heartbeat",  # NMT

   475

                                   [])           # options

   476

                self.OnCTNSave()

   477

   478

        def GetCanDevice(self):

   479

            return str(self.BaseParams.getIEC_Channel())

   480

   481

        ConfNodeMethods = [

   482

            {"bitmap" : "NetworkEdit",

   483

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

   484

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

   485

             "method" : "_OpenView"},

   486

        ] + _SlaveCTN.ConfNodeMethods

   487

   488

    class LPCNetworkEditor(NetworkEditor):

   489

        SHOW_BASE_PARAMS = False

   490

   491

    class LPCCanOpenMaster(_NodeListCTN):

   492

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

   493

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

   494

          <xsd:element name="CanFestivalNode">

   495

            <xsd:complexType>

   496

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

   497

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

   498

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

   499

            </xsd:complexType>

   500

          </xsd:element>

   501

        </xsd:schema>

   502

        """ % DEFAULT_SETTINGS

   503

   504

        EditorType = LPCNetworkEditor

   505

   506

        def GetCanDevice(self):

   507

            return str(self.BaseParams.getIEC_Channel())

   508

   509

        ConfNodeMethods = [

   510

            {"bitmap" : "NetworkEdit",

   511

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

   512

             "tooltip" : _("Edit CanOpen Network with NetworkEdit"),

   513

             "method" : "_OpenView"},

   514

        ] + _NodeListCTN.ConfNodeMethods

   515

   516

    class LPCCanOpen(CanOpenRootClass):

   517

        XSD = None

   518

        CTNChildrenTypes = [("CanOpenNode", LPCCanOpenMaster, "CanOpen Master"),

   519

                            ("CanOpenSlave", LPCCanOpenSlave, "CanOpen Slave")]