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

     9

from networkedit import networkedit

    10

from objdictedit import objdictedit

    11

import canfestival_config

    12

from plugger import PlugTemplate

    13

from commondialogs import CreateNodeDialog

    14

import wx

    15

    16

from gnosis.xml.pickle import *

    17

from gnosis.xml.pickle.util import setParanoia

    18

setParanoia(0)

    19

    20

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

    21

#                    SLAVE

    22

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

    23

    24

class _SlavePlug(NodeManager):

    25

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

    26

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

    27

      <xsd:element name="CanFestivalSlaveNode">

    28

        <xsd:complexType>

    29

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

    30

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

    31

          <xsd:attribute name="NodeId" type="xsd:string" use="required"/>

    32

        </xsd:complexType>

    33

      </xsd:element>

    34

    </xsd:schema>

    35

    """

    36

    37

    def GetSlaveODPath(self):

    38

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

    39

    40

    def __init__(self):

    41

        # TODO change netname when name change

    42

        NodeManager.__init__(self)

    43

        odfilepath = self.GetSlaveODPath()

    44

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

    45

            self.OpenFileInCurrent(odfilepath)

    46

        else:

    47

            self.FilePath = ""

    48

            dialog = CreateNodeDialog(None, wx.OK)

    49

            dialog.Type.Enable(False)

    50

            dialog.GenSYNC.Enable(False)

    51

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

    52

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

    53

                profile, filepath = dialog.GetProfile()

    54

                NMT = dialog.GetNMTManagement()

    55

                options = dialog.GetOptions()

    56

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

    57

                                   id,         # NodeID - will be changed at build time

    58

                                   "slave",    # Type

    59

                                   description,# description 

    60

                                   profile,    # profile

    61

                                   filepath,   # prfile filepath

    62

                                   NMT,        # NMT

    63

                                   options)     # options

    64

            else:

    65

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

    66

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

    67

                                   "slave",      # Type

    68

                                   "",           # description 

    69

                                   "None",       # profile

    70

                                   "", # prfile filepath

    71

                                   "heartbeat",  # NMT

    72

                                   [])           # options

    73

            dialog.Destroy()

    74

    _View = None

    75

    def _OpenView(self, logger):

    76

        if not self._View:

    77

            def _onclose():

    78

                self._View = None

    79

            def _onsave():

    80

                self.GetPlugRoot().SaveProject()

    81

            self._View = objdictedit(self.GetPlugRoot().AppFrame, self)

    82

            # TODO redefine BusId when IEC channel change

    83

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

    84

            self._View._onclose = _onclose

    85

            self._View._onsave = _onsave

    86

            self._View.Show()

    87

    88

    PluginMethods = [

    89

        {"bitmap" : os.path.join("images", "NetworkEdit"),

    90

         "name" : "Edit slave", 

    91

         "tooltip" : "Edit CanOpen slave with ObjdictEdit",

    92

         "method" : "_OpenView"},

    93

    ]

    94

    95

    def OnPlugClose(self):

    96

        if self._View:

    97

            self._View.Close()

    98

    99

    def PlugTestModified(self):

   100

        return self.ChangesToSave or self.OneFileHasChanged()

   101

   102

    def OnPlugSave(self):

   103

        return self.SaveCurrentInFile(self.GetSlaveODPath())

   104

   105

    def PlugGenerate_C(self, buildpath, locations, logger):

   106

        """

   107

        Generate C code

   108

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

   109

        @param locations: List of complete variables locations \

   110

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

   111

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

   112

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

   113

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

   114

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

   115

            }, ...]

   116

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

   117

        """

   118

        current_location = self.GetCurrentLocation()

   119

        # define a unique name for the generated C file

   120

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

   121

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

   122

        # Create a new copy of the model

   123

        slave = self.GetCurrentNodeCopy()

   124

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

   125

        # allow access to local OD from Slave PLC

   126

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

   127

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

   128

        if res :

   129

            raise Exception, res

   130

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

   131

        if res :

   132

            raise Exception, res

   133

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

   134

   135

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

   136

#                    MASTER

   137

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

   138

   139

class _NodeListPlug(NodeList):

   140

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

   141

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

   142

      <xsd:element name="CanFestivalNode">

   143

        <xsd:complexType>

   144

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

   145

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

   146

          <xsd:attribute name="NodeId" type="xsd:string" use="required"/>

   147

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

   148

        </xsd:complexType>

   149

      </xsd:element>

   150

    </xsd:schema>

   151

    """

   152

   153

    def __init__(self):

   154

        manager = NodeManager()

   155

        # TODO change netname when name change

   156

        NodeList.__init__(self, manager, self.BaseParams.getName())

   157

        self.LoadProject(self.PlugPath())

   158

   159

    _View = None

   160

    def _OpenView(self, logger):

   161

        if not self._View:

   162

            def _onclose():

   163

                self._View = None

   164

            def _onsave():

   165

                self.GetPlugRoot().SaveProject()

   166

            self._View = networkedit(self.GetPlugRoot().AppFrame, self)

   167

            # TODO redefine BusId when IEC channel change

   168

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

   169

            self._View._onclose = _onclose

   170

            self._View._onsave = _onsave

   171

            self._View.Show()

   172

   173

    def _ShowMasterGenerated(self, logger):

   174

        buildpath = self._getBuildPath()

   175

        # Eventually create build dir

   176

        if not os.path.exists(buildpath):

   177

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

   178

            return

   179

   180

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

   181

        if not os.path.exists(masterpath):

   182

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

   183

            return

   184

   185

        new_dialog = objdictedit(None, filesOpen=[masterpath])

   186

        new_dialog.Show()

   187

   188

    PluginMethods = [

   189

        {"bitmap" : os.path.join("images", "NetworkEdit"),

   190

         "name" : "Edit network", 

   191

         "tooltip" : "Edit CanOpen Network with NetworkEdit",

   192

         "method" : "_OpenView"},

   193

        {"name" : "Show Master", 

   194

         "tooltip" : "Show Master generated by config_utils",

   195

         "method" : "_ShowMasterGenerated"}

   196

    ]

   197

   198

    def OnPlugClose(self):

   199

        if self._View:

   200

            self._View.Close()

   201

   202

    def PlugTestModified(self):

   203

        return self.ChangesToSave or self.HasChanged()

   204

   205

    def OnPlugSave(self):

   206

        self.SetRoot(self.PlugPath())

   207

        return self.SaveProject() is not None

   208

   209

    def PlugGenerate_C(self, buildpath, locations, logger):

   210

        """

   211

        Generate C code

   212

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

   213

        @param locations: List of complete variables locations \

   214

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

   215

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

   216

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

   217

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

   218

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

   219

            }, ...]

   220

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

   221

        """

   222

        current_location = self.GetCurrentLocation()

   223

        # define a unique name for the generated C file

   224

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

   225

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

   226

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

   227

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

   228

        # allow access to local OD from Master PLC

   229

        pointers.update(config_utils.LocalODPointers(locations, current_location, master))

   230

        # Do generate C file.

   231

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

   232

        if res :

   233

            raise Exception, res

   234

   235

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

   236

        dump(master, file)

   237

        file.close()

   238

   239

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

   240

   241

class RootClass:

   242

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

   243

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

   244

      <xsd:element name="CanFestivalInstance">

   245

        <xsd:complexType>

   246

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

   247

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

   248

        </xsd:complexType>

   249

      </xsd:element>

   250

    </xsd:schema>

   251

    """

   252

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

   253

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

   254

    def GetParamsAttributes(self, path = None):

   255

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

   256

        for element in infos:

   257

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

   258

                for child in element["children"]:

   259

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

   260

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

   261

                        if DLL_LIST is not None:

   262

                            child["type"] = DLL_LIST

   263

                        return infos    

   264

        return infos

   265

   266

    def PlugGenerate_C(self, buildpath, locations, logger):

   267

   268

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

   269

                       "candriver" : self.CanFestivalInstance.getCAN_Driver(),

   270

                       "nodes_includes" : "",

   271

                       "board_decls" : "",

   272

                       "nodes_declare" : "",

   273

                       "nodes_init" : "",

   274

                       "nodes_open" : "",

   275

                       "nodes_close" : "",

   276

                       "nodes_send_sync" : "",

   277

                       "nodes_proceed_sync" : "",

   278

                       "slavebootups" : "",

   279

                       "slavebootup_register" : ""}

   280

        for child in self.IECSortedChilds():

   281

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

   282

            nodename = "OD_%s" % childlocstr

   283

   284

            # Try to get Slave Node

   285

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

   286

            if child_data is None:

   287

                # Not a slave -> master

   288

                child_data = getattr(child, "CanFestivalNode")

   289

                # Apply sync setting

   290

                if child_data.getSync_TPDOs():

   291

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

   292

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

   293

                # initialize and declare node table for post_SlaveBootup lookup

   294

   295

                SlaveIDs = child.GetSlaveIDs()

   296

                for id in SlaveIDs:

   297

                    format_dict["slavebootups"] += """

   298

int %s_slave_%d_booted = 0;

   299

"""%(nodename, id)

   300

                format_dict["slavebootups"] += """

   301

static void %s_post_SlaveBootup(CO_Data* d, UNS8 nodeId){

   302

    switch(nodeId){

   303

"""%(nodename)

   304

                for id in SlaveIDs:

   305

                    format_dict["slavebootups"] += """

   306

        case %d:

   307

            %s_slave_%d_booted = 1;

   308

            break;

   309

"""%(id, nodename, id)

   310

                format_dict["slavebootups"] += """

   311

        default:

   312

            break;

   313

    }

   314

    if( """

   315

                format_dict["slavebootups"] += " && ".join(["%s_slave_%d_booted"%(nodename, id) for id in SlaveIDs])

   316

   317

                format_dict["slavebootups"] += """ )

   318

        Master_post_SlaveBootup(d,nodeId);

   319

}

   320

"""

   321

                format_dict["slavebootup_register"] += """

   322

%s_Data.post_SlaveBootup = %s_post_SlaveBootup;

   323

"""%(nodename,nodename)

   324

   325

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

   326

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

   327

                   nodename,

   328

                   child_data.getCAN_Device(),

   329

                   child_data.getCAN_Baudrate())

   330

            format_dict["nodes_declare"] += 'NODE_DECLARE(%s, %s)\n    '%(

   331

                   nodename,

   332

                   child_data.getNodeId())

   333

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

   334

                   nodename,

   335

                   child_data.getNodeId())

   336

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

   337

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

   338

   339

        if sys.platform == 'win32':

   340

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

   341

                    format_dict["candriver"] += '_DEBUG.dll'

   342

            else:

   343

                format_dict["candriver"] += '.dll'

   344

   345

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

   346

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

   347

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

   348

        f = open(cf_main_path,'w')

   349

        f.write(cf_main)

   350

        f.close()

   351

   352

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

   353

   354