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

    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:

    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

        self.ExportCurrentToEDSFile(os.path.join(buildpath, "Slave_%s.eds"%prefix))

   131

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

   132

   133

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

   134

#                    MASTER

   135

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

   136

   137

class _NodeListPlug(NodeList):

   138

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

   139

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

   140

      <xsd:element name="CanFestivalNode">

   141

        <xsd:complexType>

   142

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

   143

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

   144

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

   145

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

   146

        </xsd:complexType>

   147

      </xsd:element>

   148

    </xsd:schema>

   149

    """

   150

   151

    def __init__(self):

   152

        manager = NodeManager()

   153

        # TODO change netname when name change

   154

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

   155

        self.LoadProject(self.PlugPath())

   156

   157

    _View = None

   158

    def _OpenView(self, logger):

   159

        if not self._View:

   160

            def _onclose():

   161

                self._View = None

   162

            def _onsave():

   163

                self.GetPlugRoot().SaveProject()

   164

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

   165

            # TODO redefine BusId when IEC channel change

   166

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

   167

            self._View._onclose = _onclose

   168

            self._View._onsave = _onsave

   169

            self._View.Show()

   170

   171

    def _ShowMasterGenerated(self, logger):

   172

        buildpath = self._getBuildPath()

   173

        # Eventually create build dir

   174

        if not os.path.exists(buildpath):

   175

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

   176

            return

   177

   178

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

   179

        if not os.path.exists(masterpath):

   180

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

   181

            return

   182

   184

        new_dialog.Show()

   185

   186

    PluginMethods = [

   187

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

   188

         "name" : "Edit network", 

   189

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

   190

         "method" : "_OpenView"},

   191

        {"name" : "Show Master", 

   192

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

   193

         "method" : "_ShowMasterGenerated"}

   194

    ]

   195

   196

    def OnPlugClose(self):

   197

        if self._View:

   198

            self._View.Close()

   199

   200

    def PlugTestModified(self):

   201

        return self.ChangesToSave or self.HasChanged()

   202

   203

    def OnPlugSave(self):

   204

        self.SetRoot(self.PlugPath())

   205

        return self.SaveProject() is not None

   206

   207

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

   208

        """

   209

        Generate C code

   210

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

   211

        @param locations: List of complete variables locations \

   212

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

   213

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

   214

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

   215

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

   216

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

   217

            }, ...]

   218

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

   219

        """

   220

        current_location = self.GetCurrentLocation()

   221

        # define a unique name for the generated C file

   222

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

   223

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

   224

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

   225

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

   226

        # allow access to local OD from Master PLC

   227

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

   228

        # Do generate C file.

   229

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

   230

        if res :

   231

            raise Exception, res

   232

   233

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

   234

        dump(master, file)

   235

        file.close()

   236

   237

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

   238

   239

class RootClass:

   240

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

   241

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

   242

      <xsd:element name="CanFestivalInstance">

   243

        <xsd:complexType>

   244

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

   245

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

   246

        </xsd:complexType>

   247

      </xsd:element>

   248

    </xsd:schema>

   249

    """

   252

    def GetParamsAttributes(self, path = None):

   253

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

   254

        for element in infos:

   255

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

   256

                for child in element["children"]:

   257

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

   258

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

   259

                        if DLL_LIST is not None:

   260

                            child["type"] = DLL_LIST

   261

                        return infos    

   262

        return infos

   263

   264

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

   265

   266

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

   267

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

   268

                       "nodes_includes" : "",

   269

                       "board_decls" : "",

   270

                       "nodes_declare" : "",

   271

                       "nodes_init" : "",

   272

                       "nodes_open" : "",

   273

                       "nodes_close" : "",

   274

                       "nodes_send_sync" : "",

   277

        for child in self.IECSortedChilds():

   278

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

   279

            nodename = "OD_%s" % childlocstr

   280

   281

            # Try to get Slave Node

   282

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

   283

            if child_data is None:

   284

                # Not a slave -> master

   285

                child_data = getattr(child, "CanFestivalNode")

   287

                if child_data.getSync_TPDOs():

   288

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

   289

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

   320

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

   321

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

   322

                   nodename,

   323

                   child_data.getCAN_Device(),

   324

                   child_data.getCAN_Baudrate())

   325

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

   326

                   nodename,

   327

                   child_data.getNodeId())

   328

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

   329

                   nodename,

   330

                   child_data.getNodeId())

   331

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

   332

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

   333

   334

        if sys.platform == 'win32':

   335

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

   336

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

   337

            else:

   338

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

   339

   340

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

   341

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

   342

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

   343

        f = open(cf_main_path,'w')

   344

        f.write(cf_main)

   345

        f.close()

   346

   347

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

   348

   349