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

from Beremiz import *

    62

from plugger import PluginsRoot, PlugTemplate, opjimg, connectors

    63

from plugins.canfestival import RootClass as CanOpenRootClass

    64

from plugins.canfestival.canfestival import _SlavePlug, _NodeListPlug, NodeManager

    65

from plcopen.structures import LOCATIONDATATYPES

    66

from PLCControler import LOCATION_PLUGIN, LOCATION_MODULE, LOCATION_GROUP,\

    67

                         LOCATION_VAR_INPUT, LOCATION_VAR_OUTPUT, LOCATION_VAR_MEMORY

    68

from PLCOpenEditor import IDEFrame, ProjectDialog

    69

    70

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

    71

#                          CANFESTIVAL PLUGIN HACK

    72

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

    73

# from plugins.canfestival import canfestival

    74

# class LPC_canfestival_config:

    75

#     def getCFLAGS(self, *args):

    76

#         return ""

    77

# 

    78

#     def getLDFLAGS(self, *args):

    79

#         return ""

    80

#         

    81

# canfestival.local_canfestival_config = LPC_canfestival_config() 

    82

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

    83

#                              LPCModule Class

    84

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

    85

    86

LOCATION_TYPES = {"I": LOCATION_VAR_INPUT,

    87

                  "Q": LOCATION_VAR_OUTPUT,

    88

                  "M": LOCATION_VAR_MEMORY}

    89

    90

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

    91

    92

LOCATION_SIZES = {}

    93

for size, types in LOCATIONDATATYPES.iteritems():

    94

    for type in types:

    95

        LOCATION_SIZES[type] = size

    96

    97

def _GetModuleChildren(module):

    98

    children = []

    99

    for child in module["children"]:

   100

        if child["type"] == LOCATION_GROUP:

   101

            children.extend(child["children"])

   102

        else:

   103

            children.append(child)

   104

    return children

   105

   106

def _GetVariables(module):

   107

    variables = []

   108

    for child in module["children"]:

   109

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

   110

            variables.extend(_GetVariables(child))

   111

        else:

   112

            variables.append(child)

   113

    return variables

   114

   115

def _GetLastModuleGroup(module):

   116

    group = module

   117

    for child in module["children"]:

   118

        if child["type"] == LOCATION_GROUP:

   119

            group = child

   120

    return group["children"]

   121

   122

def _GetModuleBySomething(module, something, toks):

   123

    for child in _GetModuleChildren(module):

   124

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

   125

            if len(toks) > 1:

   126

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

   127

            return child

   128

    return None

   129

   130

def _GetModuleVariable(module, location, direction):

   131

    for child in _GetModuleChildren(module):

   132

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

   133

            return child

   134

    return None

   135

   136

def _RemoveModuleChild(module, child):

   137

    if child in module["children"]:

   138

        module["children"].remove(child)

   139

    else:

   140

        for group in module["children"]:

   141

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

   142

                group["children"].remove(child)

   143

   144

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

   145

   146

/* LPCBus plugin includes */

   147

#include "app_glue.h"

   148

#ifdef _WINDOWS_H

   149

  #include "iec_types.h"

   150

#else

   151

  #include "iec_std_lib.h"

   152

#endif

   153

   154

%(declare_code)s

   155

   156

/* LPCBus plugin user variables definition */

   157

%(var_decl)s

   158

   159

/* LPCBus plugin functions */

   160

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

   161

{

   162

%(init_code)s

   163

  return 0;

   164

}

   165

   166

void __cleanup_%(location_str)s(void)

   167

{

   168

}

   169

   170

void __retrieve_%(location_str)s(void)

   171

{

   172

%(retrieve_code)s

   173

}

   174

   175

void __publish_%(location_str)s(void)

   176

{

   177

%(publish_code)s

   178

}

   179

"""

   180

   181

class LPCBus(object):

   182

   183

    def __init__(self):

   184

        self.VariableLocationTree = []

   185

        self.ResetUsedLocations()

   186

        self.Icon = None

   187

   188

    def __getitem__(self, key):

   189

        if key == "children":

   190

            return self.VariableLocationTree

   191

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

   192

   193

    def PlugEnabled(self):

   194

        return None

   195

   196

    def SetIcon(self, icon):

   197

        self.Icon = icon

   198

   199

    def _GetChildBySomething(self, something, toks):

   200

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

   201

   202

    def GetBaseTypes(self):

   203

        return self.GetPlugRoot().GetBaseTypes()

   204

   205

    def GetSizeOfType(self, type):

   206

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

   207

   208

    def _GetVariableLocationTree(self, current_location, infos):

   209

        if infos["type"] == LOCATION_MODULE:

   210

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

   211

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

   212

                    "type": infos["type"],

   213

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

   214

                    "icon": infos["icon"], 

   215

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

   216

        elif infos["type"] == LOCATION_GROUP:

   217

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

   218

                    "type": infos["type"],

   219

                    "location": "", 

   220

                    "icon": infos["icon"], 

   221

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

   222

        else:

   223

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

   224

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

   225

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

   226

                    "type": infos["type"],

   227

                    "size": size,

   228

                    "IEC_type": infos["IEC_type"],

   229

                    "var_name": infos["name"],

   230

                    "location": location,

   231

                    "description": infos["description"],

   232

                    "children": []}

   233

   234

    def GetVariableLocationTree(self):

   235

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

   236

                "type": LOCATION_PLUGIN,

   237

                "location": self.GetFullIEC_Channel(),

   238

                "icon": self.Icon, 

   239

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

   240

                             for child in self.VariableLocationTree]}

   241

   242

    def PlugTestModified(self):

   243

        return False

   244

   245

    def PlugMakeDir(self):

   246

        pass

   247

   248

    def PlugRequestSave(self):

   249

        return None

   250

   251

    def ResetUsedLocations(self):

   252

        self.UsedLocations = {}

   253

   254

    def _AddUsedLocation(self, parent, location):

   255

        num = location.pop(0)

   256

        if not parent.has_key(num):

   257

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

   258

        if len(location) > 0:

   259

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

   260

        else:

   261

            parent[num]["used"] = True

   262

   263

    def AddUsedLocation(self, location):

   264

        if len(location) > 0:

   265

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

   266

   267

    def _CheckLocationConflicts(self, parent, location):

   268

        num = location.pop(0)

   269

        if not parent.has_key(num):

   270

            return False

   271

        if len(location) > 0:

   272

            if parent[num]["used"]:

   273

                return True

   274

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

   275

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

   276

            return True

   277

        return False

   278

   279

    def CheckLocationConflicts(self, location):

   280

        if len(location) > 0:

   281

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

   282

        return False

   283

   284

    def PlugGenerate_C(self, buildpath, locations):

   285

        """

   286

        Generate C code

   287

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

   288

        @param locations: List of complete variables locations \

   289

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

   290

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

   291

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

   292

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

   293

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

   294

            }, ...]

   295

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

   296

        """

   297

        current_location = self.GetCurrentLocation()

   298

        # define a unique name for the generated C file

   299

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

   300

   301

        code_str = {"location_str": location_str,

   302

                    "var_decl": "",

   303

                    "declare_code": "",

   304

                    "init_code": "",

   305

                    "retrieve_code": "",

   306

                    "publish_code": "",

   307

                   }

   308

   309

        for module in _GetModuleChildren(self):

   310

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

   311

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

   312

   313

        # Adding variables

   314

        vars = []

   315

        self.ResetUsedLocations()

   316

        for location in locations:

   317

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

   318

            group = next = self

   319

            i = 0

   320

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

   321

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

   322

                if next is not None:

   323

                    i += 1

   324

                    group = next

   325

            var_loc = loc[i:]

   326

            for variable in _GetModuleChildren(group):

   327

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

   328

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

   329

#                        raise Exception, "Direction conflict in variable definition"

   330

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

   331

#                        raise Exception, "Type conflict in variable definition"

   332

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

   333

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

   334

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

   335

                        self.AddUsedLocation(location["LOC"])

   336

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

   337

                                 "Type": variable["IEC_type"],

   338

                                 "Retrieve": variable["retrieve"],

   339

                                 "Publish": variable["publish"],

   340

                                })

   341

                    break

   342

        base_types = self.GetPlugRoot().GetBaseTypes()

   343

        for var in vars:

   344

            prefix = ""

   345

            if var["Type"] in base_types:

   346

                prefix = "IEC_"

   347

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

   348

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

   349

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

   350

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

   351

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

   352

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

   353

   354

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

   355

        module = open(Gen_Module_path,'w')

   356

        module.write(BUS_TEXT % code_str)

   357

        module.close()

   358

   359

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

   360

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

   361

   362

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

   363

#                          LPC CanFestival Plugin Class

   364

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

   365

   366

DEFAULT_SETTINGS = {

   367

    "CAN_Baudrate": "125K",

   368

    "Slave_NodeId": 2,

   369

    "Master_NodeId": 1,

   370

}

   371

   372

class LPCCanOpenSlave(_SlavePlug):

   373

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

   374

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

   375

      <xsd:element name="CanFestivalSlaveNode">

   376

        <xsd:complexType>

   377

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

   378

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

   379

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

   380

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

   381

            <xsd:simpleType>

   382

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

   383

                    <xsd:minInclusive value="1"/>

   384

                    <xsd:maxInclusive value="99"/>

   385

                </xsd:restriction>

   386

            </xsd:simpleType>

   387

          </xsd:attribute>

   388

        </xsd:complexType>

   389

      </xsd:element>

   390

    </xsd:schema>

   391

    """ % DEFAULT_SETTINGS

   392

   393

    def __init__(self):

   394

        # TODO change netname when name change

   395

        NodeManager.__init__(self)

   396

        odfilepath = self.GetSlaveODPath()

   397

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

   398

            self.OpenFileInCurrent(odfilepath)

   399

        else:

   400

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

   401

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

   402

                               "slave",      # Type

   403

                               "",           # description 

   404

                               "None",       # profile

   405

                               "", # prfile filepath

   406

                               "heartbeat",  # NMT

   407

                               [])           # options

   408

            self.OnPlugSave()

   409

   410

    def GetCanDevice(self):

   411

        return str(self.BaseParams.getIEC_Channel())

   412

   413

class LPCCanOpenMaster(_NodeListPlug):

   414

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

   415

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

   416

      <xsd:element name="CanFestivalNode">

   417

        <xsd:complexType>

   418

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

   419

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

   420

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

   421

        </xsd:complexType>

   422

      </xsd:element>

   423

    </xsd:schema>

   424

    """ % DEFAULT_SETTINGS

   425

   426

    def GetCanDevice(self):

   427

        return str(self.BaseParams.getIEC_Channel())

   428

   429

class LPCCanOpen(CanOpenRootClass):

   430

    XSD = None

   431

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

   432

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

   433

   434

    def GetCanDriver(self):

   435

        return ""

   436

   437

    def LoadChilds(self):

   438

        PlugTemplate.LoadChilds(self)

   439

   440

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

   441

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

   442

            master.BaseParams.setEnabled(False)

   443

   444

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

   445

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

   446

            slave.BaseParams.setEnabled(False)

   447

   448

   449

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

   450

#                              LPCPluginsRoot Class

   451

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

   452

   453

def mycopytree(src, dst):

   454

    """

   455

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

   456

    @param src: source directory

   457

    @param dst: destination directory

   458

    """

   459

    for i in os.listdir(src):

   460

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

   461

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

   462

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

   463

            if os.path.isdir(srcpath):

   464

                if os.path.exists(dstpath):

   465

                    shutil.rmtree(dstpath)

   466

                os.makedirs(dstpath)

   467

                mycopytree(srcpath, dstpath)

   468

            elif os.path.isfile(srcpath):

   469

                shutil.copy2(srcpath, dstpath)

   470

   471

[SIMULATION_MODE, TRANSFER_MODE] = range(2)

   472

   473

class LPCPluginsRoot(PluginsRoot):

   474

   475

    PluginMethods = [

   476

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

   477

         "name" : _("Simulate"),

   478

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

   479

         "method" : "_Simulate"},

   480

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

   481

         "name" : _("Run"),

   482

         "shown" : False,

   483

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

   484

         "method" : "_Run"},

   485

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

   486

         "name" : _("Stop"),

   487

         "shown" : False,

   488

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

   489

         "method" : "_Stop"},

   490

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

   491

         "name" : _("Build"),

   492

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

   493

         "method" : "_Build"},

   494

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

   495

         "name" : _("Transfer"),

   496

         "shown" : False,

   497

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

   498

         "method" : "_Transfer"},

   499

    ]

   500

   501

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

   502

        self.OrigBuildPath = buildpath

   503

   504

        PluginsRoot.__init__(self, frame, logger)

   505

   506

        self.PlugChildsTypes += [("LPCBus", LPCBus, "LPC bus"), ("CanOpen", LPCCanOpen, "CanOpen bus")]

   507

        self.PlugType = "LPC"

   508

   509

        self.OnlineMode = "OFF"

   510

        self.LPCConnector = None