1

import os, sys, shutil

     2

     3

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

     4

CanFestivalPath = os.path.join(base_folder, "CanFestival-3")

     5

sys.path.append(os.path.join(CanFestivalPath, "objdictgen"))

     6

     7

import wx

     8

     9

from nodelist import NodeList

    10

from nodemanager import NodeManager

    11

import config_utils, gen_cfile, eds_utils

    12

import canfestival_config as local_canfestival_config

    13

from ConfigTreeNode import ConfigTreeNode

    14

from commondialogs import CreateNodeDialog

    15

from subindextable import IECTypeConversion, SizeConversion

    16

    17

from PLCControler import LOCATION_CONFNODE, LOCATION_MODULE, LOCATION_GROUP, LOCATION_VAR_INPUT, LOCATION_VAR_OUTPUT, LOCATION_VAR_MEMORY

    18

from SlaveEditor import SlaveEditor, MasterViewer

    19

from NetworkEditor import NetworkEditor

    20

    21

from gnosis.xml.pickle import *

    22

from gnosis.xml.pickle.util import setParanoia

    23

setParanoia(0)

    24

    25

from util.TranslationCatalogs import AddCatalog

    26

AddCatalog(os.path.join(CanFestivalPath, "objdictgen", "locale"))

    27

    28

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

    29

#              Location Tree Helper

    30

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

    31

    32

def GetSlaveLocationTree(slave_node, current_location, name):

    33

    entries = []

    34

    for index, subindex, size, entry_name in slave_node.GetMapVariableList():

    35

        subentry_infos = slave_node.GetSubentryInfos(index, subindex)

    36

        typeinfos = slave_node.GetEntryInfos(subentry_infos["type"])

    37

        if typeinfos:

    38

            entries.append({

    39

                "name": "0x%4.4x-0x%2.2x: %s" % (index, subindex, entry_name),

    40

                "type": LOCATION_VAR_MEMORY,

    41

                "size": size,

    42

                "IEC_type": IECTypeConversion.get(typeinfos["name"]),

    43

                "var_name": "%s_%4.4x_%2.2x" % ("_".join(name.split()), index, subindex),

    44

                "location": "%s%s"%(SizeConversion[size], ".".join(map(str, current_location + 

    45

                                                                                (index, subindex)))),

    46

                "description": "",

    47

                "children": []})

    48

    return  {"name": name,

    49

             "type": LOCATION_CONFNODE,

    50

             "location": ".".join([str(i) for i in current_location]) + ".x",

    51

             "children": entries

    52

    }

    53

    54

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

    55

#                    SLAVE

    56

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

    57

    58

class _SlaveCTN(NodeManager):

    59

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

    60

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

    61

      <xsd:element name="CanFestivalSlaveNode">

    62

        <xsd:complexType>

    63

          <xsd:attribute name="CAN_Device" type="xsd:string" use="optional"/>

    64

          <xsd:attribute name="CAN_Baudrate" type="xsd:string" use="optional"/>

    65

          <xsd:attribute name="NodeId" type="xsd:integer" use="optional" default="2"/>

    66

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

    67

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

    68

            <xsd:simpleType>

    69

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

    70

                    <xsd:minInclusive value="1"/>

    71

                    <xsd:maxInclusive value="99"/>

    72

                </xsd:restriction>

    73

            </xsd:simpleType>

    74

          </xsd:attribute>

    75

        </xsd:complexType>

    76

      </xsd:element>

    77

    </xsd:schema>

    78

    """

    79

    80

    EditorType = SlaveEditor

    81

    IconPath = os.path.join(CanFestivalPath, "objdictgen", "networkedit.png")

    82

    83

    def __init__(self):

    84

        # TODO change netname when name change

    85

        NodeManager.__init__(self)

    86

        odfilepath = self.GetSlaveODPath()

    87

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

    88

            self.OpenFileInCurrent(odfilepath)

    89

        else:

    90

            self.FilePath = ""

    91

            dialog = CreateNodeDialog(None, wx.OK)

    92

            dialog.Type.Enable(False)

    93

            dialog.GenSYNC.Enable(False)

    94

            if dialog.ShowModal() == wx.ID_OK:

    95

                name, id, nodetype, description = dialog.GetValues()

    96

                profile, filepath = dialog.GetProfile()

    97

                NMT = dialog.GetNMTManagement()

    98

                options = dialog.GetOptions()

    99

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

   100

                                   id,         # NodeID - will be changed at build time

   101

                                   "slave",    # Type

   102

                                   description,# description 

   103

                                   profile,    # profile

   104

                                   filepath,   # prfile filepath

   105

                                   NMT,        # NMT

   106

                                   options)     # options

   107

            else:

   108

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

   109

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

   110

                                   "slave",      # Type

   111

                                   "",           # description 

   112

                                   "None",       # profile

   113

                                   "", # prfile filepath

   114

                                   "heartbeat",  # NMT

   115

                                   [])           # options

   116

            dialog.Destroy()

   117

            self.OnCTNSave()

   118

   119

    def GetCurrentNodeName(self):

   120

        return self.CTNName()

   121

   122

    def GetSlaveODPath(self):

   123

        return os.path.join(self.CTNPath(), 'slave.od')

   124

   125

    def GetCanDevice(self):

   126

        return self.CanFestivalSlaveNode.getCAN_Device()

   127

   128

    def _OpenView(self, name=None, onlyopened=False):

   129

        ConfigTreeNode._OpenView(self, name, onlyopened)

   130

        if self._View is not None:

   131

            self._View.SetBusId(self.GetCurrentLocation())

   132

        return self._View

   133

   134

    def _ExportSlave(self):

   135

        dialog = wx.FileDialog(self.GetCTRoot().AppFrame, 

   136

                               _("Choose a file"), 

   137

                               os.path.expanduser("~"), 

   138

                               "%s.eds" % self.CTNName(),  

   139

                               _("EDS files (*.eds)|*.eds|All files|*.*"),

   140

                               wx.SAVE|wx.OVERWRITE_PROMPT)

   141

        if dialog.ShowModal() == wx.ID_OK:

   142

            result = eds_utils.GenerateEDSFile(dialog.GetPath(), self.GetCurrentNodeCopy())

   143

            if result:

   144

                self.GetCTRoot().logger.write_error(_("Error: Export slave failed\n"))

   145

        dialog.Destroy()  

   146

   147

    ConfNodeMethods = [

   148

        {"bitmap" : "ExportSlave",

   149

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

   150

         "tooltip" : _("Export CanOpen slave to EDS file"),

   151

         "method" : "_ExportSlave"},

   152

    ]

   153

   154

    def CTNTestModified(self):

   155

        return self.ChangesToSave or self.OneFileHasChanged()

   156

   157

    def OnCTNSave(self, from_project_path=None):

   158

        return self.SaveCurrentInFile(self.GetSlaveODPath())

   159

   160

    def SetParamsAttribute(self, path, value):

   161

        result = ConfigTreeNode.SetParamsAttribute(self, path, value)

   162

   163

        # Filter IEC_Channel and Name, that have specific behavior

   164

        if path == "BaseParams.IEC_Channel" and self._View is not None:

   165

            self._View.SetBusId(self.GetCurrentLocation())

   166

   167

        return result

   168

   169

    def GetVariableLocationTree(self):

   170

        current_location = self.GetCurrentLocation()

   171

        return GetSlaveLocationTree(self.CurrentNode, 

   172

                                    self.GetCurrentLocation(), 

   173

                                    self.BaseParams.getName())

   174

   175

    def CTNGenerate_C(self, buildpath, locations):

   176

        """

   177

        Generate C code

   178

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

   179

        @param locations: List of complete variables locations \

   180

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

   181

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

   182

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

   183

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

   184

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

   185

            }, ...]

   186

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

   187

        """

   188

        current_location = self.GetCurrentLocation()

   189

        # define a unique name for the generated C file

   190

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

   191

        Gen_OD_path = os.path.join(buildpath, "OD_%s.c"%prefix )

   192

        # Create a new copy of the model

   193

        slave = self.GetCurrentNodeCopy()

   194

        slave.SetNodeName("OD_%s"%prefix)

   195

        # allow access to local OD from Slave PLC

   196

        pointers = config_utils.LocalODPointers(locations, current_location, slave)

   197

        res = gen_cfile.GenerateFile(Gen_OD_path, slave, pointers)

   198

        if res :

   199

            raise Exception, res

   200

        res = eds_utils.GenerateEDSFile(os.path.join(buildpath, "Slave_%s.eds"%prefix), slave)

   201

        if res :

   202

            raise Exception, res

   203

        return [(Gen_OD_path,local_canfestival_config.getCFLAGS(CanFestivalPath))],"",False

   204

   205

    def LoadPrevious(self):

   206

        self.LoadCurrentPrevious()

   207

   208

    def LoadNext(self):

   209

        self.LoadCurrentNext()

   210

   211

    def GetBufferState(self):

   212

        return self.GetCurrentBufferState()

   213

   214

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

   215

#                    MASTER

   216

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

   217

   218

class MiniNodeManager(NodeManager):

   219

   220

    def __init__(self, parent, filepath, fullname):

   221

        NodeManager.__init__(self)

   222

   223

        self.OpenFileInCurrent(filepath)

   224

   225

        self.Parent = parent

   226

        self.Fullname = fullname

   227

   228

    def GetIconName(self):

   229

        return None

   230

   231

    def OnCloseEditor(self, view):

   232

        self.Parent.OnCloseEditor(view)

   233

   234

    def CTNFullName(self):

   235

        return self.Fullname

   236

   237

    def CTNTestModified(self):

   238

        return False

   239

   240

    def GetBufferState(self):

   241

        return self.GetCurrentBufferState()

   242

   243

    ConfNodeMethods = []

   244

   245

class _NodeManager(NodeManager):

   246

   247

    def __init__(self, parent, *args, **kwargs):

   248

        NodeManager.__init__(self, *args, **kwargs)

   249

        self.Parent = parent

   250

   251

    def __del__(self):

   252

        self.Parent = None

   253

   254

    def GetCurrentNodeName(self):

   255

        return self.Parent.CTNName()

   256

   257

    def GetCurrentNodeID(self):

   258

        return self.Parent.CanFestivalNode.getNodeId()

   259

   260

class _NodeListCTN(NodeList):

   261

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

   262

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

   263

      <xsd:element name="CanFestivalNode">

   264

        <xsd:complexType>

   265

          <xsd:attribute name="CAN_Device" type="xsd:string" use="optional"/>

   266

          <xsd:attribute name="CAN_Baudrate" type="xsd:string" use="optional"/>

   267

          <xsd:attribute name="NodeId" type="xsd:integer" use="optional" default="1"/>

   268

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

   269

        </xsd:complexType>

   270

      </xsd:element>

   271

    </xsd:schema>

   272

    """ 

   273

   274

    EditorType = NetworkEditor

   275

    IconPath = os.path.join(CanFestivalPath, "objdictgen", "networkedit.png")

   276

   277

    def __init__(self):

   278

        manager = _NodeManager(self)

   279

        NodeList.__init__(self, manager)

   280

        self.LoadProject(self.CTNPath())

   281

        self.SetNetworkName(self.BaseParams.getName())

   282

   283

    def GetCanDevice(self):

   284

        return self.CanFestivalNode.getCAN_Device()

   285

   286

    def SetParamsAttribute(self, path, value):

   287

        if path == "CanFestivalNode.NodeId":

   288

            nodeid = self.CanFestivalNode.getNodeId()

   289

            if value != nodeid:

   290

                slaves = self.GetSlaveIDs()

   291

                dir = (value - nodeid) / abs(value - nodeid)

   292

                while value in slaves and value >= 0:

   293

                    value += dir

   294

                if value < 0:

   295

                    value = nodeid

   296

   297

        value, refresh = ConfigTreeNode.SetParamsAttribute(self, path, value)

   298

        refresh_network = False

   299

   300

        # Filter IEC_Channel and Name, that have specific behavior

   301

        if path == "BaseParams.IEC_Channel" and self._View is not None:

   302

            self._View.SetBusId(self.GetCurrentLocation())

   303

        elif path == "BaseParams.Name":

   304

            self.SetNetworkName(value)

   305

            refresh_network = True

   306

        elif path == "CanFestivalNode.NodeId":

   307

            refresh_network = True

   308

   309

        if refresh_network and self._View is not None:

   310

            wx.CallAfter(self._View.RefreshBufferState)

   311

        return value, refresh

   312

   313

    def GetVariableLocationTree(self):

   314

        current_location = self.GetCurrentLocation()

   315

        nodeindexes = self.SlaveNodes.keys()

   316

        nodeindexes.sort()

   317

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

   318

                 "type": LOCATION_CONFNODE,

   319

                 "location": self.GetFullIEC_Channel(),

   320

                 "children": [GetSlaveLocationTree(self.Manager.GetCurrentNodeCopy(),

   321

                                                   current_location,

   322

                                                   _("Local entries"))] + 

   323

                             [GetSlaveLocationTree(self.SlaveNodes[nodeid]["Node"], 

   324

                                                   current_location + (nodeid,), 

   325

                                                   self.SlaveNodes[nodeid]["Name"])

   326

                              for nodeid in nodeindexes]

   327

        }

   328

   329

    _GeneratedMasterView = None

   330

    def _ShowGeneratedMaster(self):

   331

        self._OpenView("Generated master")

   332

   333

    def _OpenView(self, name=None, onlyopened=False):

   334

        if name == "Generated master":

   335

            app_frame = self.GetCTRoot().AppFrame

   336

            if self._GeneratedMasterView is None:

   337

                buildpath = self._getBuildPath()

   338

                # Eventually create build dir

   339

                if not os.path.exists(buildpath):

   340

                    self.GetCTRoot().logger.write_error(_("Error: No PLC built\n"))

   341

                    return

   342

   343

                masterpath = os.path.join(buildpath, "MasterGenerated.od")

   344

                if not os.path.exists(masterpath):

   345

                    self.GetCTRoot().logger.write_error(_("Error: No Master generated\n"))

   346

                    return

   347

   348

                manager = MiniNodeManager(self, masterpath, self.CTNFullName())

   349

                self._GeneratedMasterView = MasterViewer(app_frame.TabsOpened, manager, app_frame, name)

   350

   351

            if self._GeneratedMasterView is not None:

   352

                app_frame.EditProjectElement(self._GeneratedMasterView, self._GeneratedMasterView.GetInstancePath())

   353

   354

            return self._GeneratedMasterView

   355

        else:

   356

            ConfigTreeNode._OpenView(self, name, onlyopened)

   357

            if self._View is not None:

   358

                self._View.SetBusId(self.GetCurrentLocation())

   359

            return self._View

   360

   361

    ConfNodeMethods = [

   362

        {"bitmap" : "ShowMaster",

   363

         "name" : _("Show Master"), 

   364

         "tooltip" : _("Show Master generated by config_utils"),

   365

         "method" : "_ShowGeneratedMaster"}

   366

    ]

   367

   368

    def OnCloseEditor(self, view):

   369

        ConfigTreeNode.OnCloseEditor(self, view)

   370

        if self._GeneratedMasterView == view:

   371

            self._GeneratedMasterView = None

   372

   373

    def OnCTNClose(self):

   374

        ConfigTreeNode.OnCTNClose(self)

   375

        self._CloseView(self._GeneratedMasterView)

   376

        return True

   377

   378

    def CTNTestModified(self):

   379

        return self.ChangesToSave or self.HasChanged()

   380

   381

    def OnCTNSave(self, from_project_path=None):

   382

        self.SetRoot(self.CTNPath())

   383

        if from_project_path is not None:

   384

            shutil.copytree(self.GetEDSFolder(from_project_path), 

   385

                            self.GetEDSFolder())

   386

        return self.SaveProject() is None

   387

   388

    def CTNGenerate_C(self, buildpath, locations):

   389

        """

   390

        Generate C code

   391

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

   392

        @param locations: List of complete variables locations \

   393

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

   394

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

   395

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

   396

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

   397

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

   398

            }, ...]

   399

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

   400

        """

   401

        self._CloseView(self._GeneratedMasterView)

   402

        current_location = self.GetCurrentLocation()

   403

        # define a unique name for the generated C file

   404

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

   405

        Gen_OD_path = os.path.join(buildpath, "OD_%s.c"%prefix )

   406

        # Create a new copy of the model with DCF loaded with PDO mappings for desired location

   407

        try:

   408

            master, pointers = config_utils.GenerateConciseDCF(locations, current_location, self, self.CanFestivalNode.getSync_TPDOs(),"OD_%s"%prefix)

   409

        except config_utils.PDOmappingException, e:

   410

            raise Exception, e.message

   411

        # Do generate C file.

   412

        res = gen_cfile.GenerateFile(Gen_OD_path, master, pointers)

   413

        if res :

   414

            raise Exception, res

   415

   416

        file = open(os.path.join(buildpath, "MasterGenerated.od"), "w")

   417

        dump(master, file)

   418

        file.close()

   419

   420

        return [(Gen_OD_path,local_canfestival_config.getCFLAGS(CanFestivalPath))],"",False

   421

   422

    def LoadPrevious(self):

   423

        self.Manager.LoadCurrentPrevious()

   424

   425

    def LoadNext(self):

   426

        self.Manager.LoadCurrentNext()

   427

   428

    def GetBufferState(self):

   429

        return self.Manager.GetCurrentBufferState()

   430

   431

class RootClass:

   432

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

   433

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

   434

      <xsd:element name="CanFestivalInstance">

   435

        <xsd:complexType>

   436

          <xsd:attribute name="CAN_Driver" type="xsd:string" use="optional"/>

   437

        </xsd:complexType>

   438

      </xsd:element>

   439

    </xsd:schema>

   440

    """

   441

   442

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

   443

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

   444

    def GetParamsAttributes(self, path = None):

   445

        infos = ConfigTreeNode.GetParamsAttributes(self, path = path)

   446

        for element in infos:

   447

            if element["name"] == "CanFestivalInstance":

   448

                for child in element["children"]:

   449

                    if child["name"] == "CAN_Driver":

   450

                        child["type"] = local_canfestival_config.DLL_LIST

   451

        return infos

   452

   453

    def GetCanDriver(self):

   454

        res = self.CanFestivalInstance.getCAN_Driver()

   455

        if not res :

   456

            return ""

   457

        return res

   458

   459

    def CTNGenerate_C(self, buildpath, locations):

   460

        can_driver = self.GetCanDriver()

   461

        if can_driver is not None:

   462

            can_drivers = local_canfestival_config.DLL_LIST

   463

            if can_driver not in can_drivers :

   464

                can_driver = can_drivers[0]

   465

            can_drv_ext = self.GetCTRoot().GetBuilder().extension

   466

            can_driver_name = "libcanfestival_" + can_driver + can_drv_ext

   467

        else:

   468

            can_driver_name = ""

   469

   470

   471

        format_dict = {"locstr" : "_".join(map(str,self.GetCurrentLocation())),

   472

                       "candriver" : can_driver_name,

   473

                       "nodes_includes" : "",

   474

                       "board_decls" : "",

   475

                       "nodes_init" : "",

   476

                       "nodes_open" : "",

   477

                       "nodes_stop" : "",

   478

                       "nodes_close" : "",

   479

                       "nodes_send_sync" : "",

   480

                       "nodes_proceed_sync" : "",

   481

                       "slavebootups" : "",

   482

                       "slavebootup_register" : "",

   483

                       "post_sync" : "",

   484

                       "post_sync_register" : "",

   485

                       "pre_op" : "",