1

#!/usr/bin/env python

     2

# -*- coding: utf-8 -*-

     3

     4

__version__ = "$Revision$"

     5

     6

import os, sys, getopt, wx, tempfile

     7

from types import TupleType, StringType, UnicodeType

     8

     9

CWD = os.path.split(os.path.realpath(__file__))[0]

    10

    11

def Bpath(*args):

    12

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

    13

    14

if __name__ == '__main__':

    15

    def usage():

    16

        print "\nUsage of LPCBeremiz.py :"

    17

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

    18

    19

    try:

    20

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

    21

    except getopt.GetoptError:

    22

        # print help information and exit:

    23

        usage()

    24

        sys.exit(2)

    25

    26

    for o, a in opts:

    27

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

    28

            usage()

    29

            sys.exit()

    30

    31

    if len(args) > 2:

    32

        usage()

    33

        sys.exit()

    34

    elif len(args) == 1:

    35

        projectOpen = args[0]

    36

        buildpath = None

    37

    elif len(args) == 2:

    38

        projectOpen = args[0]

    39

        buildpath = args[1]

    40

    else:

    41

        projectOpen = None

    42

        buildpath = None

    43

    44

class PseudoLocale:

    45

    LocaleDirs = []

    46

    Domains = []

    47

    48

    def AddCatalogLookupPathPrefix(self, localedir):

    49

        self.LocaleDirs.append(localedir)

    50

    51

    def AddCatalog(self, domain):

    52

        self.Domains.append(domain)

    53

    54

# Import module for internationalization

    55

import gettext

    56

import __builtin__

    57

    58

# Define locale for wx

    59

__builtin__.__dict__['loc'] = PseudoLocale()

    60

    61

if __name__ == '__main__':

    62

    __builtin__.__dict__['_'] = wx.GetTranslation#unicode_translation

    63

    64

from Beremiz import *

    66

from plcopen.structures import LOCATIONDATATYPES

    67

from PLCControler import LOCATION_PLUGIN, LOCATION_MODULE, LOCATION_GROUP,\

    68

                         LOCATION_VAR_INPUT, LOCATION_VAR_OUTPUT, LOCATION_VAR_MEMORY

    69

from PLCOpenEditor import IDEFrame

    70

    71

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

    72

#                              LPCModule Class

    73

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

    74

    75

LOCATION_TYPES = {"I": LOCATION_VAR_INPUT,

    76

                  "Q": LOCATION_VAR_OUTPUT,

    77

                  "M": LOCATION_VAR_MEMORY}

    78

    79

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

    80

    81

LOCATION_SIZES = {}

    82

for size, types in LOCATIONDATATYPES.iteritems():

    83

    for type in types:

    84

        LOCATION_SIZES[type] = size

    85

    86

def _GetModuleChildren(module):

    87

    children = []

    88

    for child in module["children"]:

    89

        if child["type"] == LOCATION_GROUP:

    90

            children.extend(child["children"])

    91

        else:

    92

            children.append(child)

    93

    return children

    94

    95

def _GetLastModuleGroup(module):

    96

    group = module

    97

    for child in module["children"]:

    98

        if child["type"] == LOCATION_GROUP:

    99

            group = child

   100

    return group["children"]

   101

   102

def _GetModuleBySomething(module, something, toks):

   103

    for child in _GetModuleChildren(module):

   104

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

   105

            if len(toks) > 1:

   106

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

   107

            return child

   108

    return None

   109

   110

def _GetModuleVariable(module, location, direction):

   111

    for child in _GetModuleChildren(module):

   112

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

   113

            return child

   114

    return None

   115

   116

def _RemoveModuleChild(module, child):

   117

    if child in module["children"]:

   118

        module["children"].remove(child)

   119

    else:

   120

        for group in module["children"]:

   121

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

   122

                group["children"].remove(child)

   123

   124

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

   125

   126

/* LPCBus plugin includes */

   127

#include "app_glue.h"

   128

#ifdef _WINDOWS_H

   129

  #include "iec_types.h"

   130

#else

   131

  #include "iec_std_lib.h"

   132

#endif

   133

   134

%(declare_code)s

   135

   136

/* LPCBus plugin user variables definition */

   137

%(var_decl)s

   138

   139

/* LPCBus plugin functions */

   140

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

   141

{

   142

  return 0;

   143

}

   144

   145

void __cleanup_%(location_str)s(void)

   146

{

   147

}

   148

   149

void __retrieve_%(location_str)s(void)

   150

{

   151

  %(retrieve_code)s

   152

}

   153

   154

void __publish_%(location_str)s(void)

   155

{

   156

  %(publish_code)s

   157

}

   158

"""

   159

   160

class LPCBus(object):

   161

   162

    def __init__(self):

   163

        self.VariableLocationTree = []

   164

        self.ResetUsedLocations()

   165

        self.Icon = None

   166

   167

    def __getitem__(self, key):

   168

        if key == "children":

   169

            return self.VariableLocationTree

   170

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

   171

   172

    def SetIcon(self, icon):

   173

        self.Icon = icon

   174

   175

    def _GetChildBySomething(self, something, toks):

   176

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

   177

   178

    def GetBaseTypes(self):

   179

        return self.GetPlugRoot().GetBaseTypes()

   180

   181

    def GetSizeOfType(self, type):

   182

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

   183

   184

    def _GetVariableLocationTree(self, current_location, infos):

   185

        if infos["type"] == LOCATION_MODULE:

   186

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

   187

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

   188

                    "type": infos["type"],

   189

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

   190

                    "icon": infos["icon"], 

   191

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

   192

        elif infos["type"] == LOCATION_GROUP:

   193

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

   194

                    "type": infos["type"],

   195

                    "location": "", 

   196

                    "icon": infos["icon"], 

   197

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

   198

        else:

   199

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

   200

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

   201

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

   202

                    "type": infos["type"],

   203

                    "size": size,

   204

                    "IEC_type": infos["IEC_type"],

   205

                    "location": location,

   206

                    "description": infos["description"],

   207

                    "children": []}

   208

   209

    def GetVariableLocationTree(self):

   210

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

   211

                "type": LOCATION_PLUGIN,

   212

                "location": self.GetFullIEC_Channel(),

   213

                "icon": self.Icon, 

   214

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

   215

                             for child in self.VariableLocationTree]}

   216

   217

    def PlugTestModified(self):

   218

        return False

   219

   220

    def PlugMakeDir(self):

   221

        pass

   222

   223

    def PlugRequestSave(self):

   224

        return None

   225

   226

    def ResetUsedLocations(self):

   227

        self.UsedLocations = {}

   228

   229

    def _AddUsedLocation(self, parent, location):

   230

        num = location.pop(0)

   231

        if not parent.has_key(num):

   232

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

   233

        if len(location) > 0:

   234

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

   235

        else:

   236

            parent[num]["used"] = True

   237

   238

    def AddUsedLocation(self, location):

   239

        if len(location) > 0:

   240

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

   241

   242

    def _CheckLocationConflicts(self, parent, location):

   243

        num = location.pop(0)

   244

        if not parent.has_key(num):

   245

            return False

   246

        if len(location) > 0:

   247

            if parent[num]["used"]:

   248

                return True

   249

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

   250

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

   251

            return True

   252

        return False

   253

   254

    def CheckLocationConflicts(self, location):

   255

        if len(location) > 0:

   256

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

   257

        return False

   258

   259

    def PlugGenerate_C(self, buildpath, locations):

   260

        """

   261

        Generate C code

   262

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

   263

        @param locations: List of complete variables locations \

   264

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

   265

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

   266

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

   267

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

   268

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

   269

            }, ...]

   270

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

   271

        """

   272

        current_location = self.GetCurrentLocation()

   273

        # define a unique name for the generated C file

   274

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

   275

   276

        code_str = {"location_str": location_str,

   277

                    "var_decl": "",

   278

                    "declare_code": "",

   279

                    "retrieve_code": "",

   280

                    "publish_code": "",

   281

                   }

   282

   283

        # Adding variables

   284

        vars = []

   285

        self.ResetUsedLocations()

   286

        for location in locations:

   287

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

   288

            group = next = self

   289

            i = 0

   290

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

   291

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

   292

                if next is not None:

   293

                    i += 1

   294

                    group = next

   295

            var_loc = loc[i:]

   296

            for variable in group["children"]:

   297

                if variable["location"] == var_loc:

   298

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

   299

                        raise Exception, "Direction conflict in variable definition"

   300

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

   301

                        raise Exception, "Type conflict in variable definition"

   302

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

   303

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

   304

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

   305

                        self.AddUsedLocation(location["LOC"])

   306

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

   307

                                 "Type": variable["IEC_type"],

   308

                                 "Declare": variable["declare"],

   309

                                 "Retrieve": variable["retrieve"],

   310

                                 "Publish": variable["publish"],

   311

                                })

   312

                    break

   313

        base_types = self.GetPlugRoot().GetBaseTypes()

   314

        for var in vars:

   315

            prefix = ""

   316

            if var["Type"] in base_types:

   317

                prefix = "IEC_"

   318

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

   319

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

   320

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

   321

                code_str["declare_code"] += var["Declare"] + "\n"

   322

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

   323

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

   324

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

   325

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

   326

   327

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

   328

        module = open(Gen_Module_path,'w')

   329

        module.write(BUS_TEXT % code_str)

   330

        module.close()

   331

   332

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

   333

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

   334

   335

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

   336

#                              LPCPluginsRoot Class

   337

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

   338

   339

def mycopytree(src, dst):

   340

    """

   341

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

   342

    @param src: source directory

   343

    @param dst: destination directory

   344

    """

   345

    for i in os.listdir(src):

   346

        if not i.startswith('.'):

   347

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

   348

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

   349

            if os.path.isdir(srcpath):

   350

                os.makedirs(dstpath)

   351

                mycopytree(srcpath, dstpath)

   352

            elif os.path.isfile(srcpath):

   353

                shutil.copy2(srcpath, dstpath)

   354

   355

class LPCPluginsRoot(PluginsRoot):

   356

   357

    PluginMethods = [

   362

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

   363

         "name" : _("Run"),

   364

         "shown" : False,

   365

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

   366

         "method" : "_Run"},

   367

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

   368

         "name" : _("Stop"),

   369

         "shown" : False,

   370

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

   371

         "method" : "_Stop"},

   376

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

   377

         "name" : _("Transfer"),

   378

         "shown" : False,

   379

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

   380

         "method" : "_Transfer"},

   381

    ]

   382

   383

    def __init__(self, frame, logger):

   384

        PluginsRoot.__init__(self, frame, logger)

   385

   386

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

   387

   388

        self.OnlineMode = 0

   389

        self.OnlinePath = None

   395

   396

    def GetProjectName(self):

   397

        return self.Project.getname()

   398

   399

    def GetDefaultTarget(self):

   400

        target = self.Classes["BeremizRoot_TargetType"]()

   412

        return target

   422

    def SetProjectName(self, name):

   423

        return self.Project.setname(name)

   424

   425

    def SetOnlineMode(self, mode, path=None):

   471

   472

    # Update a PLCOpenEditor Pou variable name

   473

    def UpdateProjectVariableName(self, old_name, new_name):

   474

        self.Project.updateElementName(old_name, new_name)

   475

        self.BufferProject()

   476

   477

    def RemoveProjectVariableByAddress(self, address):

   478

        self.Project.removeVariableByAddress(address)

   479

        self.BufferProject()

   480

   481

    def RemoveProjectVariableByFilter(self, leading):

   482

        self.Project.removeVariableByFilter(leading)

   483

        self.BufferProject()

   484

   485

    def LoadProject(self, ProjectPath, BuildPath=None):

   486

        """

   487

        Load a project contained in a folder

   488

        @param ProjectPath: path of the project folder

   489

        """

   490

        if os.path.basename(ProjectPath) == "":

   491

            ProjectPath = os.path.dirname(ProjectPath)

   492

        # Verify that project contains a PLCOpen program

   493

        plc_file = os.path.join(ProjectPath, "plc.xml")

   494

        if not os.path.isfile(plc_file):

   495

            return _("Chosen folder doesn't contain a program. It's not a valid project!")

   496

        # Load PLCOpen file

   497

        result = self.OpenXMLFile(plc_file)

   498

        if result:

   499

            return result

   500

        # Change XSD into class members

   501

        self._AddParamsMembers()

   502

        self.PluggedChilds = {}

   503

        # Keep track of the root plugin (i.e. project path)

   504

        self.ProjectPath = ProjectPath

   505

        self.BuildPath = self._getBuildPath()

   506

        if BuildPath is not None:

   507

            mycopytree(BuildPath, self.BuildPath)

   508

   509

        # If dir have already be made, and file exist

   510

        if os.path.isdir(self.PlugPath()) and os.path.isfile(self.PluginXmlFilePath()):

   511

            #Load the plugin.xml file into parameters members

   512

            result = self.LoadXMLParams()

   513

            if result:

   514

                return result

   515

            #Load and init all the childs

   516

            self.LoadChilds()

   517

        self.RefreshPluginsBlockLists()