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

from types import TupleType, StringType, UnicodeType

    10

    11

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

    12

    13

def Bpath(*args):

    14

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

    15

    16

if __name__ == '__main__':

    17

    def usage():

    18

        print "\nUsage of LPCBeremiz.py :"

    19

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

    20

    21

    try:

    22

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

    23

    except getopt.GetoptError:

    24

        # print help information and exit:

    25

        usage()

    26

        sys.exit(2)

    27

    28

    for o, a in opts:

    29

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

    30

            usage()

    31

            sys.exit()

    32

    33

    if len(args) != 3:

    34

        usage()

    35

        sys.exit()

    36

    else:

    37

        projectOpen = args[0]

    38

        buildpath = args[1]

    39

        try:

    40

            port = int(args[2])

    41

        except:

    42

            usage()

    43

            sys.exit()

    44

    45

app = wx.PySimpleApp()

    46

app.SetAppName('beremiz')

    47

wx.InitAllImageHandlers()

    48

    49

# Import module for internationalization

    50

import gettext

    51

import __builtin__

    52

    53

if __name__ == '__main__':

    54

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

    55

    56

from Beremiz import *

    57

from plugger import PluginsRoot, PlugTemplate, opjimg, connectors

    58

from plcopen.structures import LOCATIONDATATYPES

    59

from PLCControler import LOCATION_PLUGIN, LOCATION_MODULE, LOCATION_GROUP,\

    60

                         LOCATION_VAR_INPUT, LOCATION_VAR_OUTPUT, LOCATION_VAR_MEMORY

    61

from PLCOpenEditor import IDEFrame, ProjectDialog

    62

    63

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

    64

#                          CANFESTIVAL PLUGIN HACK

    65

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

    66

from plugins.canfestival import canfestival

    67

class LPC_canfestival_config:

    68

    def getCFLAGS(self, *args):

    69

        return ""

    70

    71

    def getLDFLAGS(self, *args):

    72

        return ""

    73

    74

canfestival.local_canfestival_config = LPC_canfestival_config() 

    75

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

    76

#                              LPCModule Class

    77

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

    78

    79

LOCATION_TYPES = {"I": LOCATION_VAR_INPUT,

    80

                  "Q": LOCATION_VAR_OUTPUT,

    81

                  "M": LOCATION_VAR_MEMORY}

    82

    83

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

    84

    85

LOCATION_SIZES = {}

    86

for size, types in LOCATIONDATATYPES.iteritems():

    87

    for type in types:

    88

        LOCATION_SIZES[type] = size

    89

    90

def _GetModuleChildren(module):

    91

    children = []

    92

    for child in module["children"]:

    93

        if child["type"] == LOCATION_GROUP:

    94

            children.extend(child["children"])

    95

        else:

    96

            children.append(child)

    97

    return children

    98

    99

def _GetVariables(module):

   100

    variables = []

   101

    for child in module["children"]:

   102

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

   103

            variables.extend(_GetVariables(child))

   104

        else:

   105

            variables.append(child)

   106

    return variables

   107

   108

def _GetLastModuleGroup(module):

   109

    group = module

   110

    for child in module["children"]:

   111

        if child["type"] == LOCATION_GROUP:

   112

            group = child

   113

    return group["children"]

   114

   115

def _GetModuleBySomething(module, something, toks):

   116

    for child in _GetModuleChildren(module):

   117

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

   118

            if len(toks) > 1:

   119

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

   120

            return child

   121

    return None

   122

   123

def _GetModuleVariable(module, location, direction):

   124

    for child in _GetModuleChildren(module):

   125

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

   126

            return child

   127

    return None

   128

   129

def _RemoveModuleChild(module, child):

   130

    if child in module["children"]:

   131

        module["children"].remove(child)

   132

    else:

   133

        for group in module["children"]:

   134

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

   135

                group["children"].remove(child)

   136

   137

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

   138

   139

/* LPCBus plugin includes */

   140

#include "app_glue.h"

   141

#ifdef _WINDOWS_H

   142

  #include "iec_types.h"

   143

#else

   144

  #include "iec_std_lib.h"

   145

#endif

   146

   147

%(declare_code)s

   148

   149

/* LPCBus plugin user variables definition */

   150

%(var_decl)s

   151

   152

/* LPCBus plugin functions */

   153

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

   154

{

   155

%(init_code)s

   156

  return 0;

   157

}

   158

   159

void __cleanup_%(location_str)s(void)

   160

{

   161

}

   162

   163

void __retrieve_%(location_str)s(void)

   164

{

   165

%(retrieve_code)s

   166

}

   167

   168

void __publish_%(location_str)s(void)

   169

{

   170

%(publish_code)s

   171

}

   172

"""

   173

   174

class LPCBus(object):

   175

   176

    def __init__(self):

   177

        self.VariableLocationTree = []

   178

        self.ResetUsedLocations()

   179

        self.Icon = None

   180

   181

    def __getitem__(self, key):

   182

        if key == "children":

   183

            return self.VariableLocationTree

   184

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

   185

   186

    def SetIcon(self, icon):

   187

        self.Icon = icon

   188

   189

    def _GetChildBySomething(self, something, toks):

   190

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

   191

   192

    def GetBaseTypes(self):

   193

        return self.GetPlugRoot().GetBaseTypes()

   194

   195

    def GetSizeOfType(self, type):

   196

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

   197

   198

    def _GetVariableLocationTree(self, current_location, infos):

   199

        if infos["type"] == LOCATION_MODULE:

   200

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

   201

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

   202

                    "type": infos["type"],

   203

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

   204

                    "icon": infos["icon"], 

   205

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

   206

        elif infos["type"] == LOCATION_GROUP:

   207

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

   208

                    "type": infos["type"],

   209

                    "location": "", 

   210

                    "icon": infos["icon"], 

   211

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

   212

        else:

   213

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

   214

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

   215

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

   216

                    "type": infos["type"],

   217

                    "size": size,

   218

                    "IEC_type": infos["IEC_type"],

   219

                    "location": location,

   220

                    "description": infos["description"],

   221

                    "children": []}

   222

   223

    def GetVariableLocationTree(self):

   224

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

   225

                "type": LOCATION_PLUGIN,

   226

                "location": self.GetFullIEC_Channel(),

   227

                "icon": self.Icon, 

   228

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

   229

                             for child in self.VariableLocationTree]}

   230

   231

    def PlugTestModified(self):

   232

        return False

   233

   234

    def PlugMakeDir(self):

   235

        pass

   236

   237

    def PlugRequestSave(self):

   238

        return None

   239

   240

    def ResetUsedLocations(self):

   241

        self.UsedLocations = {}

   242

   243

    def _AddUsedLocation(self, parent, location):

   244

        num = location.pop(0)

   245

        if not parent.has_key(num):

   246

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

   247

        if len(location) > 0:

   248

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

   249

        else:

   250

            parent[num]["used"] = True

   251

   252

    def AddUsedLocation(self, location):

   253

        if len(location) > 0:

   254

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

   255

   256

    def _CheckLocationConflicts(self, parent, location):

   257

        num = location.pop(0)

   258

        if not parent.has_key(num):

   259

            return False

   260

        if len(location) > 0:

   261

            if parent[num]["used"]:

   262

                return True

   263

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

   264

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

   265

            return True

   266

        return False

   267

   268

    def CheckLocationConflicts(self, location):

   269

        if len(location) > 0:

   270

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

   271

        return False

   272

   273

    def PlugGenerate_C(self, buildpath, locations):

   274

        """

   275

        Generate C code

   276

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

   277

        @param locations: List of complete variables locations \

   278

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

   279

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

   280

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

   281

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

   282

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

   283

            }, ...]

   284

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

   285

        """

   286

        current_location = self.GetCurrentLocation()

   287

        # define a unique name for the generated C file

   288

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

   289

   290

        code_str = {"location_str": location_str,

   291

                    "var_decl": "",

   292

                    "declare_code": "",

   293

                    "init_code": "",

   294

                    "retrieve_code": "",

   295

                    "publish_code": "",

   296

                   }

   297

   298

        for module in _GetModuleChildren(self):

   299

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

   300

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

   301

   302

        # Adding variables

   303

        vars = []

   304

        self.ResetUsedLocations()

   305

        for location in locations:

   306

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

   307

            group = next = self

   308

            i = 0

   309

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

   310

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

   311

                if next is not None:

   312

                    i += 1

   313

                    group = next

   314

            var_loc = loc[i:]

   315

            for variable in _GetModuleChildren(group):

   316

                if variable["location"] == var_loc:

   317

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

   318

#                        raise Exception, "Direction conflict in variable definition"

   319

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

   320

#                        raise Exception, "Type conflict in variable definition"

   321

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

   322

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

   323

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

   324

                        self.AddUsedLocation(location["LOC"])

   325

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

   326

                                 "Type": variable["IEC_type"],

   327

                                 "Retrieve": variable["retrieve"],

   328

                                 "Publish": variable["publish"],

   329

                                })

   330

                    break

   331

        base_types = self.GetPlugRoot().GetBaseTypes()

   332

        for var in vars:

   333

            prefix = ""

   334

            if var["Type"] in base_types:

   335

                prefix = "IEC_"

   336

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

   337

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

   338

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

   339

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

   340

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

   341

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

   342

   343

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

   344

        module = open(Gen_Module_path,'w')

   345

        module.write(BUS_TEXT % code_str)

   346

        module.close()

   347

   348

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

   349

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

   350

   351

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

   352

#                              LPCPluginsRoot Class

   353

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

   354

   355

def mycopytree(src, dst):

   356

    """

   357

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

   358

    @param src: source directory

   359

    @param dst: destination directory

   360

    """

   361

    for i in os.listdir(src):

   362

        if not i.startswith('.'):

   363

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

   364

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

   365

            if os.path.isdir(srcpath):

   366

                if os.path.exists(dstpath):

   367

                    shutil.rmtree(dstpath)

   368

                os.makedirs(dstpath)

   369

                mycopytree(srcpath, dstpath)

   370

            elif os.path.isfile(srcpath):

   371

                shutil.copy2(srcpath, dstpath)

   372

   373

[SIMULATION_MODE, TRANSFER_MODE] = range(2)

   374

   375

class LPCPluginsRoot(PluginsRoot):

   376

   377

    PluginMethods = [

   378

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

   379

         "name" : _("Simulate"),

   380

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

   381

         "method" : "_Simulate"},

   382

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

   383

         "name" : _("Run"),

   384

         "shown" : False,

   385

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

   386

         "method" : "_Run"},

   387

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

   388

         "name" : _("Stop"),

   389

         "shown" : False,

   390

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

   391

         "method" : "_Stop"},

   392

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

   393

         "name" : _("Build"),

   394

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

   395

         "method" : "_build"},

   396

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

   397

         "name" : _("Transfer"),

   398

         "shown" : False,

   399

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

   400

         "method" : "_Transfer"},

   401

    ]

   402

   403

    def __init__(self, frame, logger):

   404

        PluginsRoot.__init__(self, frame, logger)

   405

   406

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

   407

   408

        self.OnlineMode = "OFF"

   409

        self.LPCConnector = False

   410

   411

        self.CurrentMode = None

   412

        self.previous_mode = None

   413

   414

        self.SimulationBuildPath = None

   415

   416

        self.AbortTransferTimer = None

   417

   418

    def GetProjectName(self):

   419

        return self.Project.getname()

   420

   421

    def GetDefaultTargetName(self):

   422

        if self.CurrentMode == SIMULATION_MODE:

   423

            return PluginsRoot.GetDefaultTargetName(self)

   424

        else:

   425

            return "LPC"

   426

   427

    def GetTarget(self):

   428

        target = PluginsRoot.GetTarget(self)

   429

        if self.CurrentMode != SIMULATION_MODE:

   430

            target.getcontent()["value"].setBuildPath(self.BuildPath)

   431

        return target

   432

   433

    def _getBuildPath(self):

   434

        if self.CurrentMode == SIMULATION_MODE:

   435

            if self.SimulationBuildPath is None:

   436

                self.SimulationBuildPath = os.path.join(tempfile.mkdtemp(), os.path.basename(self.ProjectPath), "build")

   437

            return self.SimulationBuildPath

   438

        else:

   439

            return PluginsRoot._getBuildPath(self)

   440

   441

    def _build(self):

   442

        if self.BuildPath is not None:

   443

            mycopytree(self.OrigBuildPath, self.BuildPath)

   444

        PluginsRoot._build(self)

   445

   446

    def SetProjectName(self, name):

   447

        return self.Project.setname(name)

   448

   449

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

   450

        if self.OnlineMode != mode.upper():

   451

            self.OnlineMode = mode.upper()

   452

   453

            if self.OnlineMode != "OFF":

   454

                uri = "LPC://%s/%s" % (self.OnlineMode,path)

   455

                try:

   456

                    self.LPCConnector = connectors.ConnectorFactory(uri, self)

   457

                except Exception, msg:

   458

                    self.logger.write_error(_("Exception while connecting %s!\n")%uri)

   459

                    self.logger.write_error(traceback.format_exc())

   460

   461

                # Did connection success ?

   462

                if self.LPCConnector is None:

   463

                    # Oups.

   464

                    self.logger.write_error(_("Connection failed to %s!\n")%uri)

   465

   466

            else:

   467

                self.LPCConnector = None

   468

   469

            self.ApplyOnlineMode()

   470

   471

    def ApplyOnlineMode(self):

   472

        if self.CurrentMode != SIMULATION_MODE:

   473

            self.KillDebugThread()

   474

   475

            self._connector = self.LPCConnector

   476

   477

            # Init with actual PLC status and print it

   478

            self.UpdateMethodsFromPLCStatus()

   479

   480

            if self.LPCConnector is not None and self.OnlineMode == "APPLICATION":

   481

   482

                self.CompareLocalAndRemotePLC()

   483

   484

                if self.previous_plcstate is not None:

   485

                    status = _(self.previous_plcstate)

   486

                else:

   487

                    status = ""

   488

                self.logger.write(_("PLC is %s\n")%status)

   489

   490

                if self.StatusTimer and not self.StatusTimer.IsRunning():

   491

                    # Start the status Timer

   492

                    self.StatusTimer.Start(milliseconds=500, oneShot=False)

   493

   494

                if self.previous_plcstate=="Started":

   495

                    if self.DebugAvailable() and self.GetIECProgramsAndVariables():

   496

                        self.logger.write(_("Debug connect matching running PLC\n"))

   497

                        self._connect_debug()

   498

                    else:

   499

                        self.logger.write_warning(_("Debug do not match PLC - stop/transfert/start to re-enable\n"))

   500

   501

            elif self.StatusTimer and self.StatusTimer.IsRunning():

   502

                self.StatusTimer.Stop()

   503

   504

            if self.CurrentMode == TRANSFER_MODE:

   505

   506

                if self.OnlineMode == "BOOTLOADER":

   507

                    self.BeginTransfer()

   508

   509

                elif self.OnlineMode == "APPLICATION":

   510

                    self.CurrentMode = None