1

import os, sys

     2

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

     3

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

     4

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

     5

     6

from nodelist import NodeList

     7

from nodemanager import NodeManager

     8

import config_utils, gen_cfile, eds_utils

     9

from networkedit import networkedit

    10

from objdictedit import objdictedit

    11

import canfestival_config as local_canfestival_config

    12

from ConfigTreeNode import ConfigTreeNode

    13

from commondialogs import CreateNodeDialog

    14

import wx

    15

    16

from SlaveEditor import SlaveEditor, MasterViewer

    17

from NetworkEditor import NetworkEditor

    18

    19

from gnosis.xml.pickle import *

    20

from gnosis.xml.pickle.util import setParanoia

    21

setParanoia(0)

    22

    23

if wx.Platform == '__WXMSW__':

    24

    DEFAULT_SETTINGS = {

    25

        "CAN_Driver": "can_tcp_win32",

    26

        "CAN_Device": "127.0.0.1",

    27

        "CAN_Baudrate": "125K",

    28

        "Slave_NodeId": 2,

    29

        "Master_NodeId": 1,

    30

    }

    31

else:

    32

    DEFAULT_SETTINGS = {

    33

        "CAN_Driver": "../CanFestival-3/drivers/can_socket/libcanfestival_can_socket.so",

    34

        "CAN_Device": "vcan0",

    35

        "CAN_Baudrate": "125K",

    36

        "Slave_NodeId": 2,

    37

        "Master_NodeId": 1,

    38

    }

    39

    40

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

    41

#                    SLAVE

    42

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

    43

    44

class _SlaveCTN(NodeManager):

    45

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

    46

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

    47

      <xsd:element name="CanFestivalSlaveNode">

    48

        <xsd:complexType>

    49

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

    50

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

    51

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

    52

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

    53

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

    54

            <xsd:simpleType>

    55

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

    56

                    <xsd:minInclusive value="1"/>

    57

                    <xsd:maxInclusive value="99"/>

    58

                </xsd:restriction>

    59

            </xsd:simpleType>

    60

          </xsd:attribute>

    61

        </xsd:complexType>

    62

      </xsd:element>

    63

    </xsd:schema>

    64

    """ % DEFAULT_SETTINGS

    65

    66

    EditorType = SlaveEditor

    67

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

    68

    69

    def __init__(self):

    70

        # TODO change netname when name change

    71

        NodeManager.__init__(self)

    72

        odfilepath = self.GetSlaveODPath()

    73

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

    74

            self.OpenFileInCurrent(odfilepath)

    75

        else:

    76

            self.FilePath = ""

    77

            dialog = CreateNodeDialog(None, wx.OK)

    78

            dialog.Type.Enable(False)

    79

            dialog.GenSYNC.Enable(False)

    80

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

    81

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

    82

                profile, filepath = dialog.GetProfile()

    83

                NMT = dialog.GetNMTManagement()

    84

                options = dialog.GetOptions()

    85

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

    86

                                   id,         # NodeID - will be changed at build time

    87

                                   "slave",    # Type

    88

                                   description,# description 

    89

                                   profile,    # profile

    90

                                   filepath,   # prfile filepath

    91

                                   NMT,        # NMT

    92

                                   options)     # options

    93

            else:

    94

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

    95

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

    96

                                   "slave",      # Type

    97

                                   "",           # description 

    98

                                   "None",       # profile

    99

                                   "", # prfile filepath

   100

                                   "heartbeat",  # NMT

   101

                                   [])           # options

   102

            dialog.Destroy()

   103

            self.OnCTNSave()

   104

   105

    def GetSlaveODPath(self):

   106

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

   107

   108

    def GetCanDevice(self):

   109

        return self.CanFestivalSlaveNode.getCan_Device()

   110

   111

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

   112

        ConfigTreeNode._OpenView(self, name, onlyopened)

   113

        if self._View is not None:

   114

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

   115

        return self._View

   116

   117

    def _ExportSlave(self):

   118

        dialog = wx.FileDialog(self.GetCTRoot().AppFrame, _("Choose a file"), os.getcwd(), "",  _("EDS files (*.eds)|*.eds|All files|*.*"), wx.SAVE|wx.OVERWRITE_PROMPT)

   119

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

   120

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

   121

            if result:

   122

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

   123

        dialog.Destroy()  

   124

   125

    ConfNodeMethods = [

   126

        {"bitmap" : "ExportSlave",

   127

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

   128

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

   129

         "method" : "_ExportSlave"},

   130

    ]

   131

   132

    def CTNTestModified(self):

   133

        return self.ChangesToSave or self.OneFileHasChanged()

   134

   135

    def OnCTNSave(self):

   136

        return self.SaveCurrentInFile(self.GetSlaveODPath())

   137

   138

    def SetParamsAttribute(self, path, value):

   139

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

   140

   141

        # Filter IEC_Channel and Name, that have specific behavior

   142

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

   143

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

   144

   145

        return result

   146

   147

    def CTNGenerate_C(self, buildpath, locations):

   148

        """

   149

        Generate C code

   150

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

   151

        @param locations: List of complete variables locations \

   152

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

   153

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

   154

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

   155

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

   156

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

   157

            }, ...]

   158

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

   159

        """

   160

        current_location = self.GetCurrentLocation()

   161

        # define a unique name for the generated C file

   162

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

   163

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

   164

        # Create a new copy of the model

   165

        slave = self.GetCurrentNodeCopy()

   166

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

   167

        # allow access to local OD from Slave PLC

   168

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

   169

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

   170

        if res :

   171

            raise Exception, res

   172

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

   173

        if res :

   174

            raise Exception, res

   175

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

   176

   177

    def LoadPrevious(self):

   178

        self.LoadCurrentPrevious()

   179

   180

    def LoadNext(self):

   181

        self.LoadCurrentNext()

   182

   183

    def GetBufferState(self):

   184

        return self.GetCurrentBufferState()

   185

   186

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

   187

#                    MASTER

   188

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

   189

   190

class MiniNodeManager(NodeManager):

   191

   192

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

   193

        NodeManager.__init__(self)

   194

   195

        self.OpenFileInCurrent(filepath)

   196

   197

        self.Parent = parent

   198

        self.Fullname = fullname

   199

   200

    def GetIconName(self):

   201

        return None

   202

   203

    def OnCloseEditor(self, view):

   204

        self.Parent.OnCloseEditor(view)

   205

   206

    def CTNFullName(self):

   207

        return self.Fullname

   208

   209

    def CTNTestModified(self):

   210

        return False

   211

   212

    def GetBufferState(self):

   213

        return self.GetCurrentBufferState()

   214

   215

    ConfNodeMethods = []

   216

   217

class _NodeListCTN(NodeList):

   218

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

   219

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

   220

      <xsd:element name="CanFestivalNode">

   221

        <xsd:complexType>

   222

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

   223

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

   224

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

   225

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

   226

        </xsd:complexType>

   227

      </xsd:element>

   228

    </xsd:schema>

   229

    """ % DEFAULT_SETTINGS

   230

   231

    EditorType = NetworkEditor

   232

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

   233

   234

    def __init__(self):

   235

        manager = NodeManager()

   236

        NodeList.__init__(self, manager)

   237

        self.LoadProject(self.CTNPath())

   238

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

   239

   240

    def GetCanDevice(self):

   241

        return self.CanFestivalNode.getCan_Device()

   242

   243

    def SetParamsAttribute(self, path, value):

   244

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

   245

   246

        # Filter IEC_Channel and Name, that have specific behavior

   247

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

   248

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

   249

        elif path == "BaseParams.Name":

   250

            self.SetNetworkName(value)

   251

   252

        return result

   253

   254

    _GeneratedMasterView = None

   255

    def _ShowGeneratedMaster(self):

   256

        self._OpenView("Generated master")

   257

   258

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

   259

        if name == "Generated master":

   260

            app_frame = self.GetCTRoot().AppFrame

   261

            if self._GeneratedMasterView is None:

   262

                buildpath = self._getBuildPath()

   263

                # Eventually create build dir

   264

                if not os.path.exists(buildpath):

   265

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

   266

                    return

   267

   268

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

   269

                if not os.path.exists(masterpath):

   270

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

   271

                    return

   272

   273

                manager = MiniNodeManager(self, masterpath, self.CTNFullName() + ".generated_master")

   274

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

   275

   276

            if self._GeneratedMasterView is not None:

   277

                app_frame.EditProjectElement(self._IECCodeView, name)

   278

   279

            return self._GeneratedMasterView

   280

        else:

   281

            ConfigTreeNode._OpenView(self, name, onlyopened)

   282

            if self._View is not None:

   283

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

   284

            return self._View

   285

   286

    ConfNodeMethods = [

   287

        {"bitmap" : "ShowMaster",

   288

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

   289

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

   290

         "method" : "_ShowGeneratedMaster"}

   291

    ]

   292

   293

    def OnCloseEditor(self, view):

   294

        ConfigTreeNode.OnCloseEditor(self, view)

   295

        if self._GeneratedMasterView == view:

   296

            self._GeneratedMasterView = None

   297

   298

    def OnCTNClose(self):

   299

        ConfigTreeNode.OnCTNClose(self)

   300

        self._CloseView(self._GeneratedMasterView)

   301

        return True

   302

   303

    def CTNTestModified(self):

   304

        return self.ChangesToSave or self.HasChanged()

   305

   306

    def OnCTNSave(self):

   307

        self.SetRoot(self.CTNPath())

   308

        return self.SaveProject() is None

   309

   310

    def CTNGenerate_C(self, buildpath, locations):

   311

        """

   312

        Generate C code

   313

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

   314

        @param locations: List of complete variables locations \

   315

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

   316

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

   317

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

   318

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

   319

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

   320

            }, ...]

   321

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

   322

        """

   323

        self._CloseView(self._GeneratedMasterView)

   324

        current_location = self.GetCurrentLocation()

   325

        # define a unique name for the generated C file

   326

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

   327

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

   328

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

   329

        try:

   330

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

   331

        except config_utils.PDOmappingException, e:

   332

            raise Exception, e.message

   333

        # Do generate C file.

   334

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

   335

        if res :

   336

            raise Exception, res

   337

   338

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

   339

        dump(master, file)

   340

        file.close()

   341

   342

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

   343

   344

    def LoadPrevious(self):

   345

        self.Manager.LoadCurrentPrevious()

   346

   347

    def LoadNext(self):

   348

        self.Manager.LoadCurrentNext()

   349

   350

    def GetBufferState(self):

   351

        return self.Manager.GetCurrentBufferState()

   352

   353

class RootClass:

   354

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

   355

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

   356

      <xsd:element name="CanFestivalInstance">

   357

        <xsd:complexType>

   358

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

   359

          <xsd:attribute name="Debug_mode" type="xsd:boolean" use="optional" default="false"/>

   360

        </xsd:complexType>

   361

      </xsd:element>

   362

    </xsd:schema>

   363

    """ % DEFAULT_SETTINGS

   364

   365

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

   366

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

   367

    def GetParamsAttributes(self, path = None):

   368

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

   369

        for element in infos:

   370

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

   371

                for child in element["children"]:

   372

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

   373

                        DLL_LIST= getattr(local_canfestival_config,"DLL_LIST",None)

   374

                        if DLL_LIST is not None:

   375

                            child["type"] = DLL_LIST  

   376

        return infos

   377

   378

    def GetCanDriver(self):

   379

        can_driver = self.CanFestivalInstance.getCAN_Driver()

   380

        if sys.platform == 'win32':

   381

            if self.CanFestivalInstance.getDebug_mode() and os.path.isfile(os.path.join("%s"%(can_driver + '_DEBUG.dll'))):

   382

                can_driver += '_DEBUG.dll'

   383

            else:

   384

                can_driver += '.dll'

   385

        return can_driver

   386

   387

    def CTNGenerate_C(self, buildpath, locations):

   388

   389

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

   390

                       "candriver" : self.GetCanDriver(),

   391

                       "nodes_includes" : "",

   392

                       "board_decls" : "",

   393

                       "nodes_init" : "",

   394

                       "nodes_open" : "",

   395

                       "nodes_stop" : "",

   396

                       "nodes_close" : "",

   397

                       "nodes_send_sync" : "",

   398

                       "nodes_proceed_sync" : "",

   399

                       "slavebootups" : "",

   400

                       "slavebootup_register" : "",

   401

                       "post_sync" : "",

   402

                       "post_sync_register" : "",

   403

                       }

   404

        for child in self.IECSortedChildren():

   405

            childlocstr = "_".join(map(str,child.GetCurrentLocation()))

   406

            nodename = "OD_%s" % childlocstr

   407

   408

            # Try to get Slave Node

   409

            child_data = getattr(child, "CanFestivalSlaveNode", None)

   410

            if child_data is None:

   411

                # Not a slave -> master

   412

                child_data = getattr(child, "CanFestivalNode")

   413

                # Apply sync setting

   414

                format_dict["nodes_init"] += 'NODE_MASTER_INIT(%s, %s)\n    '%(

   415

                       nodename,

   416

                       child_data.getNodeId())

   417

                if child_data.getSync_TPDOs():

   418

                    format_dict["nodes_send_sync"] += 'NODE_SEND_SYNC(%s)\n    '%(nodename)

   419

                    format_dict["nodes_proceed_sync"] += 'NODE_PROCEED_SYNC(%s)\n    '%(nodename)

   420

   421

                # initialize and declare node boot status variables for post_SlaveBootup lookup

   422

                SlaveIDs = child.GetSlaveIDs()

   423

                if len(SlaveIDs) == 0:

   424

                    # define post_SlaveBootup lookup functions

   425

                    format_dict["slavebootups"] += (

   426

                        "static void %s_post_SlaveBootup(CO_Data* d, UNS8 nodeId){}\n"%(nodename))

   427

                else:

   428

                    # for id in SlaveIDs:

   429

                    #     format_dict["slavebootups"] += (

   430

                    #     "int %s_slave_%d_booted = 0;\n"%(nodename, id))

   431

                    # define post_SlaveBootup lookup functions

   432

                    format_dict["slavebootups"] += (

   433

                        "static void %s_post_SlaveBootup(CO_Data* d, UNS8 nodeId){\n"%(nodename)+

   434

                        "    check_and_start_node(d, nodeId);\n"+

   435

                        "}\n")

   436

                # register previously declared func as post_SlaveBootup callback for that node

   437

                format_dict["slavebootup_register"] += (

   438

                    "%s_Data.post_SlaveBootup = %s_post_SlaveBootup;\n"%(nodename,nodename))

   439

            else:

   440

                # Slave node

   441

                align = child_data.getSync_Align()

   442

                align_ratio=child_data.getSync_Align_Ratio()

   443

                if align > 0:

   444

                    format_dict["post_sync"] += (

   445

                        "static int %s_CalCount = 0;\n"%(nodename)+

   446

                        "static void %s_post_sync(CO_Data* d){\n"%(nodename)+

   447

                        "    if(%s_CalCount < %d){\n"%(nodename, align)+

   448

                        "        %s_CalCount++;\n"%(nodename)+

   449

                        "        align_tick(-1);\n"+

   450

                        "    }else{\n"+

   451

                        "        align_tick(%d);\n"%(align_ratio)+

   452

                        "    }\n"+

   453

                        "}\n")

   454

                    format_dict["post_sync_register"] += (

   455

                        "%s_Data.post_sync = %s_post_sync;\n"%(nodename,nodename))

   456

                format_dict["nodes_init"] += 'NODE_SLAVE_INIT(%s, %s)\n    '%(

   457

                       nodename,

   458

                       child_data.getNodeId())

   459

   460

            # Include generated OD headers

   461

            format_dict["nodes_includes"] += '#include "%s.h"\n'%(nodename)

   462

            # Declare CAN channels according user filled config

   463

            format_dict["board_decls"] += 'BOARD_DECL(%s, "%s", "%s")\n'%(

   464

                   nodename,

   465

                   child.GetCanDevice(),

   466

                   child_data.getCAN_Baudrate())

   467

            format_dict["nodes_open"] += 'NODE_OPEN(%s)\n    '%(nodename)

   468

            format_dict["nodes_close"] += 'NODE_CLOSE(%s)\n    '%(nodename)

   469

            format_dict["nodes_stop"] += 'NODE_STOP(%s)\n    '%(nodename)

   470

   471

        filename = os.path.join(os.path.split(__file__)[0],"cf_runtime.c")

   472

        cf_main = open(filename).read() % format_dict

   473

        cf_main_path = os.path.join(buildpath, "CF_%(locstr)s.c"%format_dict)

   474

        f = open(cf_main_path,'w')

   475

        f.write(cf_main)

   476

        f.close()

   477

   478

        return [(cf_main_path, local_canfestival_config.getCFLAGS(CanFestivalPath))],local_canfestival_config.getLDFLAGS(CanFestivalPath), True

   479

   480