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_folder = os.path.split(sys.path[0])[0]

    62

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

    63

    64

_base_path = path.split(__file__)[0]

    65

    66

from Beremiz import *

    67

from ProjectController import ProjectController

    68

from ConfigTreeNode import ConfigTreeNode

    69

    70

import connectors

    71

from LPCconnector import LPC_connector_factory

    72

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

    73

    74

import targets

    75

from LPCtarget import LPC_target 

    76

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

    77

                        "class": LPC_target,

    78

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

    79

    80

from util import opjimg

    81

from plcopen.structures import LOCATIONDATATYPES

    82

from PLCControler import LOCATION_CONFNODE, LOCATION_MODULE, LOCATION_GROUP,\

    83

                         LOCATION_VAR_INPUT, LOCATION_VAR_OUTPUT, LOCATION_VAR_MEMORY

    84

from PLCOpenEditor import IDEFrame, ProjectDialog

    85

    86

havecanfestival = False

    87

try:

    88

    from canfestival import RootClass as CanOpenRootClass

    89

    from canfestival.canfestival import _SlaveCTN, _NodeListCTN, NodeManager

    90

    havecanfestival = True

    91

except:

    92

    havecanfestival = False

    93

    94

    95

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

    96

#                          CANFESTIVAL CONFNODE HACK

    97

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

    98

# from canfestival import canfestival

    99

# class LPC_canfestival_config:

   100

#     def getCFLAGS(self, *args):

   101

#         return ""

   102

# 

   103

#     def getLDFLAGS(self, *args):

   104

#         return ""

   105

#         

   106

# canfestival.local_canfestival_config = LPC_canfestival_config() 

   107

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

   108

#                              LPCModule Class

   109

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

   110

   111

LOCATION_TYPES = {"I": LOCATION_VAR_INPUT,

   112

                  "Q": LOCATION_VAR_OUTPUT,

   113

                  "M": LOCATION_VAR_MEMORY}

   114

   115

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

   116

   117

LOCATION_SIZES = {}

   118

for size, types in LOCATIONDATATYPES.iteritems():

   119

    for type in types:

   120

        LOCATION_SIZES[type] = size

   121

   122

def _GetModuleChildren(module):

   123

    children = []

   124

    for child in module["children"]:

   125

        if child["type"] == LOCATION_GROUP:

   126

            children.extend(child["children"])

   127

        else:

   128

            children.append(child)

   129

    return children

   130

   131

def _GetVariables(module):

   132

    variables = []

   133

    for child in module["children"]:

   134

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

   135

            variables.extend(_GetVariables(child))

   136

        else:

   137

            variables.append(child)

   138

    return variables

   139

   140

def _GetLastModuleGroup(module):

   141

    group = module

   142

    for child in module["children"]:

   143

        if child["type"] == LOCATION_GROUP:

   144

            group = child

   145

    return group["children"]

   146

   147

def _GetModuleBySomething(module, something, toks):

   148

    for child in _GetModuleChildren(module):

   149

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

   150

            if len(toks) > 1:

   151

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

   152

            return child

   153

    return None

   154

   155

def _GetModuleVariable(module, location, direction):

   156

    for child in _GetModuleChildren(module):

   157

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

   158

            return child

   159

    return None

   160

   161

def _RemoveModuleChild(module, child):

   162

    if child in module["children"]:

   163

        module["children"].remove(child)

   164

    else:

   165

        for group in module["children"]:

   166

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

   167

                group["children"].remove(child)

   168

   169

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

   170

   171

/* LPCBus confnode includes */

   172

#include "app_glue.h"

   173

#ifdef _WINDOWS_H

   174

  #include "iec_types.h"

   175

#else

   176

  #include "iec_std_lib.h"

   177

#endif

   178

   179

%(declare_code)s

   180

   181

/* LPCBus confnode user variables definition */

   182

%(var_decl)s

   183

   184

/* LPCBus confnode functions */

   185

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

   186

{

   187

%(init_code)s

   188

  return 0;

   189

}

   190

   191

void __cleanup_%(location_str)s(void)

   192

{

   193

}

   194

   195

void __retrieve_%(location_str)s(void)

   196

{

   197

%(retrieve_code)s

   198

}

   199

   200

void __publish_%(location_str)s(void)

   201

{

   202

%(publish_code)s

   203

}

   204

"""

   205

   206

class LPCBus(object):

   207

   208

    def __init__(self):

   209

        self.VariableLocationTree = []

   210

        self.ResetUsedLocations()

   211

        self.Icon = None

   212

   213

    def __getitem__(self, key):

   214

        if key == "children":

   215

            return self.VariableLocationTree

   216

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

   217

   218

    def CTNEnabled(self):

   219

        return None

   220

   221

    def SetIcon(self, icon):

   222

        self.Icon = icon

   223

   224

    def _GetChildBySomething(self, something, toks):

   225

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

   226

   227

    def GetBaseTypes(self):

   228

        return self.GetCTRoot().GetBaseTypes()

   229

   230

    def GetSizeOfType(self, type):

   231

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

   232

   233

    def _GetVariableLocationTree(self, current_location, infos):

   234

        if infos["type"] == LOCATION_MODULE:

   235

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

   236

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

   237

                    "type": infos["type"],

   238

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

   239

                    "icon": infos["icon"], 

   240

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

   241

        elif infos["type"] == LOCATION_GROUP:

   242

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

   243

                    "type": infos["type"],

   244

                    "location": "", 

   245

                    "icon": infos["icon"], 

   246

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

   247

        else:

   248

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

   249

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

   250

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

   251

                    "type": infos["type"],

   252

                    "size": size,

   253

                    "IEC_type": infos["IEC_type"],

   254

                    "var_name": infos["name"],

   255

                    "location": location,

   256

                    "description": infos["description"],

   257

                    "children": []}

   258

   259

    def GetVariableLocationTree(self):

   260

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

   261

                "type": LOCATION_CONFNODE,

   262

                "location": self.GetFullIEC_Channel(),

   263

                "icon": self.Icon, 

   264

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

   265

                             for child in self.VariableLocationTree]}

   266

   267

    def CTNTestModified(self):

   268

        return False

   269

   270

    def CTNMakeDir(self):

   271

        pass

   272

   273

    def CTNRequestSave(self):

   274

        return None

   275

   276

    def ResetUsedLocations(self):

   277

        self.UsedLocations = {}

   278

   279

    def _AddUsedLocation(self, parent, location):

   280

        num = location.pop(0)

   281

        if not parent.has_key(num):

   282

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

   283

        if len(location) > 0:

   284

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

   285

        else:

   286

            parent[num]["used"] = True

   287

   288

    def AddUsedLocation(self, location):

   289

        if len(location) > 0:

   290

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

   291

   292

    def _CheckLocationConflicts(self, parent, location):

   293

        num = location.pop(0)

   294

        if not parent.has_key(num):

   295

            return False

   296

        if len(location) > 0:

   297

            if parent[num]["used"]:

   298

                return True

   299

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

   300

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

   301

            return True

   302

        return False

   303

   304

    def CheckLocationConflicts(self, location):

   305

        if len(location) > 0:

   306

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

   307

        return False

   308

   309

    def CTNGenerate_C(self, buildpath, locations):

   310

        """

   311

        Generate C code

   312

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

   313

        @param locations: List of complete variables locations \

   314

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

   315

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

   316

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

   317

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

   318

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

   319

            }, ...]

   320

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

   321

        """

   322

        current_location = self.GetCurrentLocation()

   323

        # define a unique name for the generated C file

   324

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

   325

   326

        code_str = {"location_str": location_str,

   327

                    "var_decl": "",

   328

                    "declare_code": "",

   329

                    "init_code": "",

   330

                    "retrieve_code": "",

   331

                    "publish_code": "",

   332

                   }

   333

   334

        for module in _GetModuleChildren(self):

   335

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

   336

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

   337

   338

        # Adding variables

   339

        vars = []

   340

        self.ResetUsedLocations()

   341

        for location in locations:

   342

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

   343

            group = next = self

   344

            i = 0

   345

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

   346

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

   347

                if next is not None:

   348

                    i += 1

   349

                    group = next

   350

            var_loc = loc[i:]

   351

            for variable in _GetModuleChildren(group):

   352

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

   353

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

   354

#                        raise Exception, "Direction conflict in variable definition"

   355

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

   356

#                        raise Exception, "Type conflict in variable definition"

   357

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

   358

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

   359

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

   360

                        self.AddUsedLocation(location["LOC"])

   361

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

   362

                                 "Type": variable["IEC_type"],

   363

                                 "Retrieve": variable["retrieve"],

   364

                                 "Publish": variable["publish"],

   365

                                })

   366

                    break

   367

        base_types = self.GetCTRoot().GetBaseTypes()

   368

        for var in vars:

   369

            prefix = ""

   370

            if var["Type"] in base_types:

   371

                prefix = "IEC_"

   372

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

   373

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

   374

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

   375

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

   376

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

   377

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

   378

   379

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

   380

        module = open(Gen_Module_path,'w')

   381

        module.write(BUS_TEXT % code_str)

   382

        module.close()

   383

   384

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

   385

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

   386

   387

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

   388

#                          LPC CanFestival ConfNode Class

   389

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

   390

   391

if havecanfestival:

   392

   393

    DEFAULT_SETTINGS = {

   394

        "CAN_Baudrate": "125K",

   395

        "Slave_NodeId": 2,

   396

        "Master_NodeId": 1,

   397

    }

   398

   399

    class LPCCanOpenSlave(_SlaveCTN):

   400

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

   401

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

   402

          <xsd:element name="CanFestivalSlaveNode">

   403

            <xsd:complexType>

   404

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

   405

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

   406

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

   407

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

   408

                <xsd:simpleType>

   409

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

   410

                        <xsd:minInclusive value="1"/>

   411

                        <xsd:maxInclusive value="99"/>

   412

                    </xsd:restriction>

   413

                </xsd:simpleType>

   414

              </xsd:attribute>

   415

            </xsd:complexType>

   416

          </xsd:element>

   417

        </xsd:schema>

   418

        """ % DEFAULT_SETTINGS

   419

   420

        def __init__(self):

   421

            # TODO change netname when name change

   422

            NodeManager.__init__(self)

   423

            odfilepath = self.GetSlaveODPath()

   424

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

   425

                self.OpenFileInCurrent(odfilepath)

   426

            else:

   427

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

   428

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

   429

                                   "slave",      # Type

   430

                                   "",           # description 

   431

                                   "None",       # profile

   432

                                   "", # prfile filepath

   433

                                   "heartbeat",  # NMT

   434

                                   [])           # options

   435

                self.OnCTNSave()

   436

   437

        def GetCanDevice(self):

   438

            return str(self.BaseParams.getIEC_Channel())

   439

   440

    class LPCCanOpenMaster(_NodeListCTN):

   441

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

   442

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

   443

          <xsd:element name="CanFestivalNode">

   444

            <xsd:complexType>

   445

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

   446

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

   447

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

   448

            </xsd:complexType>

   449

          </xsd:element>

   450

        </xsd:schema>

   451

        """ % DEFAULT_SETTINGS

   452

   453

        def GetCanDevice(self):

   454

            return str(self.BaseParams.getIEC_Channel())

   455

   456

    class LPCCanOpen(CanOpenRootClass):

   457

        XSD = None

   458

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

   459

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

   460

   461

        def GetCanDriver(self):

   462

            return ""

   463

   464

        def LoadChildren(self):

   465

            ConfigTreeNode.LoadChildren(self)

   466

   467

            if self.GetChildByName("Master") is None:

   468

                master = self.CTNAddChild("Master", "CanOpenNode", 0)

   469

                master.BaseParams.setEnabled(False)

   470

   471

            if self.GetChildByName("Slave") is None:

   472

                slave = self.CTNAddChild("Slave", "CanOpenSlave", 1)

   473

                slave.BaseParams.setEnabled(False)

   474

   475

   476

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

   477

#                              LPCProjectController Class

   478

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

   479

   480

def mycopytree(src, dst):

   481

    """

   482

    Copy content of a directory to an other, omit hidden files

   483

    @param src: source directory

   484

    @param dst: destination directory

   485

    """

   486

    for i in os.listdir(src):

   487

        if not i.startswith('.') and i != "pous.xml":

   488

            srcpath = os.path.join(src,i)

   489

            dstpath = os.path.join(dst,i)

   490

            if os.path.isdir(srcpath):

   491

                if os.path.exists(dstpath):

   492

                    shutil.rmtree(dstpath)

   493

                os.makedirs(dstpath)

   494

                mycopytree(srcpath, dstpath)

   495

            elif os.path.isfile(srcpath):

   496

                shutil.copy2(srcpath, dstpath)

   497

   498

[SIMULATION_MODE, TRANSFER_MODE] = range(2)

   499

   500

class LPCProjectController(ProjectController):

   501

   502

    ConfNodeMethods = [

   503

        {"bitmap" : opjimg("Debug"),

   504

         "name" : _("Simulate"),

   505

         "tooltip" : _("Simulate PLC"),

   506

         "method" : "_Simulate"},

   507

        {"bitmap" : opjimg("Run"),

   508

         "name" : _("Run"),

   509

         "shown" : False,

   510

         "tooltip" : _("Start PLC"),

   511

         "method" : "_Run"},

   512

        {"bitmap" : opjimg("Stop"),

   513

         "name" : _("Stop"),

   514

         "shown" : False,

   515

         "tooltip" : _("Stop Running PLC"),

   516

         "method" : "_Stop"},

   517

        {"bitmap" : opjimg("Build"),

   518

         "name" : _("Build"),

   519

         "tooltip" : _("Build project into build folder"),

   520

         "method" : "_Build"},

   521

        {"bitmap" : opjimg("Transfer"),

   522

         "name" : _("Transfer"),

   523

         "shown" : False,

   524

         "tooltip" : _("Transfer PLC"),

   525

         "method" : "_Transfer"},

   526

    ]

   527

   528

    def __init__(self, frame, logger, buildpath):

   529

        self.OrigBuildPath = buildpath

   530